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

package/lib/queryBuilder/operations/RunAfterOperation.js

@@ -1,29 +1,23 @@
 'use strict';
-
 const { QueryBuilderOperation } = require('./QueryBuilderOperation');
-
 class RunAfterOperation extends QueryBuilderOperation {
-  constructor(name, opt) {
-    super(name, opt);
-    this.func = null;
-  }
-
-  onAdd(_, args) {
-    this.func = args[0];
-    return true;
-  }
-
-  onAfter3(builder, result) {
-    return this.func.call(builder, result, builder);
-  }
-
-  clone() {
-    const clone = super.clone();
-    clone.func = this.func;
-    return clone;
-  }
+    constructor(name, opt) {
+        super(name, opt);
+        this.func = null;
+    }
+    onAdd(_, args) {
+        this.func = args[0];
+        return true;
+    }
+    onAfter3(builder, result) {
+        return this.func.call(builder, result, builder);
+    }
+    clone() {
+        const clone = super.clone();
+        clone.func = this.func;
+        return clone;
+    }
 }
-
 module.exports = {
-  RunAfterOperation,
+    RunAfterOperation,
 };

package/lib/queryBuilder/operations/RunBeforeOperation.js

@@ -1,29 +1,23 @@
 'use strict';
-
 const { QueryBuilderOperation } = require('./QueryBuilderOperation');
-
 class RunBeforeOperation extends QueryBuilderOperation {
-  constructor(name, opt) {
-    super(name, opt);
-    this.func = null;
-  }
-
-  onAdd(_, args) {
-    this.func = args[0];
-    return true;
-  }
-
-  onBefore1(builder, result) {
-    return this.func.call(builder, result, builder);
-  }
-
-  clone() {
-    const clone = super.clone();
-    clone.func = this.func;
-    return clone;
-  }
+    constructor(name, opt) {
+        super(name, opt);
+        this.func = null;
+    }
+    onAdd(_, args) {
+        this.func = args[0];
+        return true;
+    }
+    onBefore1(builder, result) {
+        return this.func.call(builder, result, builder);
+    }
+    clone() {
+        const clone = super.clone();
+        clone.func = this.func;
+        return clone;
+    }
 }
-
 module.exports = {
-  RunBeforeOperation,
+    RunBeforeOperation,
 };

package/lib/queryBuilder/operations/UnrelateOperation.js

@@ -1,23 +1,18 @@
 'use strict';
-
 const { QueryBuilderOperation } = require('./QueryBuilderOperation');
-
 class UnrelateOperation extends QueryBuilderOperation {
-  constructor(name, opt) {
-    super(name, opt);
-
-    this.relation = opt.relation;
-    this.owner = opt.owner;
-    this.ids = null;
-  }
-
-  clone() {
-    const clone = super.clone();
-    clone.ids = this.ids;
-    return clone;
-  }
+    constructor(name, opt) {
+        super(name, opt);
+        this.relation = opt.relation;
+        this.owner = opt.owner;
+        this.ids = null;
+    }
+    clone() {
+        const clone = super.clone();
+        clone.ids = this.ids;
+        return clone;
+    }
 }
-
 module.exports = {
-  UnrelateOperation,
+    UnrelateOperation,
 };

package/lib/queryBuilder/operations/UpdateAndFetchOperation.js

@@ -1,80 +1,63 @@
 'use strict';
-
 const { withWhereScope } = require('../whereScopes');
 const { DelegateOperation } = require('./DelegateOperation');
 const { FindByIdOperation } = require('./FindByIdOperation');
 const { UpdateOperation } = require('./UpdateOperation');
-
 class UpdateAndFetchOperation extends DelegateOperation {
-  constructor(name, opt) {
-    super(name, opt);
-
-    if (!this.delegate.is(UpdateOperation)) {
-      throw new Error('Invalid delegate');
+    constructor(name, opt) {
+        super(name, opt);
+        if (!this.delegate.is(UpdateOperation)) {
+            throw new Error('Invalid delegate');
+        }
+        this.id = null;
+        this.skipIdWhere = false;
     }
-
-    this.id = null;
-    this.skipIdWhere = false;
-  }
-
-  get model() {
-    return this.delegate.model;
-  }
-
-  onAdd(builder, args) {
-    this.id = args[0];
-    return this.delegate.onAdd(builder, args.slice(1));
-  }
-
-  onBuild(builder) {
-    if (!this.skipIdWhere) {
-      withWhereScope(builder, () => builder.findById(this.id));
+    get model() {
+        return this.delegate.model;
     }
-
-    super.onBuild(builder);
-  }
-
-  async onAfter2(builder, numUpdated) {
-    if (numUpdated == 0) {
-      // If nothing was updated, we should fetch nothing.
-      await super.onAfter2(builder, numUpdated);
-      return undefined;
+    onAdd(builder, args) {
+        this.id = args[0];
+        return this.delegate.onAdd(builder, args.slice(1));
     }
-
-    const fetched = await builder
-      .emptyInstance()
-      .childQueryOf(builder)
-      .modify((builder) => {
+    onBuild(builder) {
         if (!this.skipIdWhere) {
-          builder.findById(this.id);
+            withWhereScope(builder, () => builder.findById(this.id));
+        }
+        super.onBuild(builder);
+    }
+    async onAfter2(builder, numUpdated) {
+        if (numUpdated == 0) {
+            // If nothing was updated, we should fetch nothing.
+            await super.onAfter2(builder, numUpdated);
+            return undefined;
         }
-      })
-      .castTo(builder.resultModelClass());
-
-    if (fetched) {
-      this.model.$set(fetched);
+        const fetched = await builder
+            .emptyInstance()
+            .childQueryOf(builder)
+            .modify((builder) => {
+            if (!this.skipIdWhere) {
+                builder.findById(this.id);
+            }
+        })
+            .castTo(builder.resultModelClass());
+        if (fetched) {
+            this.model.$set(fetched);
+        }
+        await super.onAfter2(builder, numUpdated);
+        return fetched ? this.model : undefined;
+    }
+    toFindOperation() {
+        return new FindByIdOperation('findById', {
+            id: this.id,
+        });
+    }
+    clone() {
+        const clone = super.clone();
+        clone.id = this.id;
+        clone.skipIdWhere = this.skipIdWhere;
+        return clone;
     }
-
-    await super.onAfter2(builder, numUpdated);
-    return fetched ? this.model : undefined;
-  }
-
-  toFindOperation() {
-    return new FindByIdOperation('findById', {
-      id: this.id,
-    });
-  }
-
-  clone() {
-    const clone = super.clone();
-
-    clone.id = this.id;
-    clone.skipIdWhere = this.skipIdWhere;
-
-    return clone;
-  }
 }
-
 module.exports = {
-  UpdateAndFetchOperation,
+    UpdateAndFetchOperation,
 };

package/lib/queryBuilder/operations/UpdateOperation.js

@@ -1,155 +1,130 @@
 'use strict';
-
 const { ref } = require('../../queryBuilder/ReferenceBuilder');
 const { isEmpty } = require('../../utils/objectUtils');
 const { isKnexRaw, isKnexQueryBuilder } = require('../../utils/knexUtils');
 const { toPgJsonPathLiteral, getJsonDialect } = require('../../utils/postgresJsonPath');
-const { toMySqlJsonPath } = require('../../utils/mysqlJsonPath');
+const { toMySqlJsonPath, toJsonSql } = require('../../utils/mysqlJsonPath');
 const { QueryBuilderOperation } = require('./QueryBuilderOperation');
-const { StaticHookArguments } = require('../StaticHookArguments');
-
+const { StaticHookArguments, hasStaticHook } = require('../StaticHookArguments');
 class UpdateOperation extends QueryBuilderOperation {
-  constructor(name, opt) {
-    super(name, opt);
-
-    this.model = null;
-    this.modelOptions = Object.assign({}, this.opt.modelOptions || {});
-  }
-
-  onAdd(builder, args) {
-    const json = args[0];
-    const modelClass = builder.modelClass();
-
-    this.model = modelClass.ensureModel(json, this.modelOptions);
-    return true;
-  }
-
-  async onBefore2(builder, result) {
-    await callBeforeUpdate(builder, this.model, this.modelOptions);
-    return result;
-  }
-
-  onBefore3(builder) {
-    const row = this.model.$toDatabaseJson(builder);
-
-    if (isEmpty(row)) {
-      // Resolve the query if there is nothing to update.
-      builder.resolve(0);
+    constructor(name, opt) {
+        super(name, opt);
+        this.model = null;
+        this.modelOptions = Object.assign({}, this.opt.modelOptions || {});
+    }
+    onAdd(builder, args) {
+        const json = args[0];
+        const modelClass = builder.modelClass();
+        this.model = modelClass.ensureModel(json, this.modelOptions);
+        return true;
+    }
+    async onBefore2(builder, result) {
+        await callBeforeUpdate(builder, this.model, this.modelOptions);
+        return result;
+    }
+    onBefore3(builder) {
+        const row = this.model.$toDatabaseJson(builder);
+        if (isEmpty(row)) {
+            // Resolve the query if there is nothing to update.
+            builder.resolve(0);
+        }
+    }
+    onBuildKnex(knexBuilder, builder) {
+        const json = this.model.$toDatabaseJson(builder);
+        const convertedJson = convertFieldExpressionsToRaw(builder, this.model, json);
+        return knexBuilder.update(convertedJson);
+    }
+    onAfter2(builder, numUpdated) {
+        return callAfterUpdate(builder, this.model, this.modelOptions, numUpdated);
+    }
+    toFindOperation() {
+        return null;
+    }
+    clone() {
+        const clone = super.clone();
+        clone.model = this.model;
+        return clone;
     }
-  }
-
-  onBuildKnex(knexBuilder, builder) {
-    const json = this.model.$toDatabaseJson(builder);
-    const convertedJson = convertFieldExpressionsToRaw(builder, this.model, json);
-
-    return knexBuilder.update(convertedJson);
-  }
-
-  onAfter2(builder, numUpdated) {
-    return callAfterUpdate(builder, this.model, this.modelOptions, numUpdated);
-  }
-
-  toFindOperation() {
-    return null;
-  }
-
-  clone() {
-    const clone = super.clone();
-    clone.model = this.model;
-    return clone;
-  }
 }
-
 async function callBeforeUpdate(builder, model, modelOptions) {
-  await callInstanceBeforeUpdate(builder, model, modelOptions);
-  return callStaticBeforeUpdate(builder);
+    await callInstanceBeforeUpdate(builder, model, modelOptions);
+    return callStaticBeforeUpdate(builder);
 }
-
 function callInstanceBeforeUpdate(builder, model, modelOptions) {
-  return model.$beforeUpdate(modelOptions, builder.context());
+    return model.$beforeUpdate(modelOptions, builder.context());
 }
-
 function callStaticBeforeUpdate(builder) {
-  const args = StaticHookArguments.create({ builder });
-  return builder.modelClass().beforeUpdate(args);
+    if (!hasStaticHook(builder.modelClass(), 'beforeUpdate')) {
+        return undefined;
+    }
+    const args = StaticHookArguments.create({ builder });
+    return builder.modelClass().beforeUpdate(args);
 }
-
 async function callAfterUpdate(builder, model, modelOptions, result) {
-  await callInstanceAfterUpdate(builder, model, modelOptions);
-  return callStaticAfterUpdate(builder, result);
+    await callInstanceAfterUpdate(builder, model, modelOptions);
+    return callStaticAfterUpdate(builder, result);
 }
-
 function callInstanceAfterUpdate(builder, model, modelOptions) {
-  return model.$afterUpdate(modelOptions, builder.context());
+    return model.$afterUpdate(modelOptions, builder.context());
 }
-
 async function callStaticAfterUpdate(builder, result) {
-  const args = StaticHookArguments.create({ builder, result });
-  const maybeResult = await builder.modelClass().afterUpdate(args);
-
-  if (maybeResult === undefined) {
-    return result;
-  } else {
-    return maybeResult;
-  }
+    if (!hasStaticHook(builder.modelClass(), 'afterUpdate')) {
+        return result;
+    }
+    const args = StaticHookArguments.create({ builder, result });
+    const maybeResult = await builder.modelClass().afterUpdate(args);
+    if (maybeResult === undefined) {
+        return result;
+    }
+    else {
+        return maybeResult;
+    }
 }
-
 function convertFieldExpressionsToRaw(builder, model, json) {
-  const knex = builder.knex();
-  const convertedJson = {};
-
-  for (const key of Object.keys(json)) {
-    let val = json[key];
-
-    if (key.indexOf(':') > -1) {
-      // 'col:attr' : ref('other:lol') is transformed to
-      // "col" : raw(`jsonb_set(COALESCE("col", '{}'), '{attr}', to_jsonb("other"#>'{lol}'), true)`)
-      // on postgres and to
-      // `col` : raw("JSON_SET(COALESCE(`col`, JSON_OBJECT()), '$.\"attr\"', JSON_EXTRACT(`other`, '$.\"lol\"'))")
-      // on mysql. A NULL column is treated as an empty object (or array).
-
-      const parsed = ref(key);
-      const access = parsed.parsedExpr.access;
-      const isSqlValue = isKnexQueryBuilder(val) || isKnexRaw(val);
-      // When the column is set by an earlier key, that expression is used instead.
-      const target = convertedJson[parsed.column] || parsed.column;
-      const isFirstSet = !convertedJson[parsed.column];
-
-      if (!isSqlValue) {
-        val = JSON.stringify(val);
-      }
-
-      if (getJsonDialect(knex, key) === 'mysql') {
-        const empty = access[0].type === 'array' ? 'JSON_ARRAY()' : 'JSON_OBJECT()';
-        const column = isFirstSet ? `COALESCE(??, ${empty})` : '??';
-        const value = isSqlValue ? '?' : 'CAST(? AS JSON)';
-
-        convertedJson[parsed.column] = knex.raw(`JSON_SET(${column}, ?, ${value})`, [
-          target,
-          toMySqlJsonPath(access),
-          val,
-        ]);
-      } else {
-        const empty = access[0].type === 'array' ? `'[]'::jsonb` : `'{}'::jsonb`;
-        const column = isFirstSet ? `COALESCE(??, ${empty})` : '??';
-        const value = isSqlValue ? 'to_jsonb(?)' : '?';
-
-        convertedJson[parsed.column] = knex.raw(
-          `jsonb_set(${column}, ${toPgJsonPathLiteral(access)}, ${value}, true)`,
-          [target, val],
-        );
-      }
-
-      delete model[key];
-    } else {
-      convertedJson[key] = val;
+    const knex = builder.knex();
+    const convertedJson = {};
+    for (const key of Object.keys(json)) {
+        let val = json[key];
+        if (key.indexOf(':') > -1) {
+            // 'col:attr' : ref('other:lol') is transformed to
+            // "col" : raw(`jsonb_set(COALESCE("col", '{}'), '{attr}', to_jsonb("other"#>'{lol}'), true)`)
+            // on postgres and to
+            // `col` : raw("JSON_SET(COALESCE(`col`, JSON_OBJECT()), '$.\"attr\"', JSON_EXTRACT(`other`, '$.\"lol\"'))")
+            // on mysql. A NULL column is treated as an empty object (or array).
+            const parsed = ref(key);
+            const access = parsed.parsedExpr.access;
+            const isSqlValue = isKnexQueryBuilder(val) || isKnexRaw(val);
+            // When the column is set by an earlier key, that expression is used instead.
+            const target = convertedJson[parsed.column] || parsed.column;
+            const isFirstSet = !convertedJson[parsed.column];
+            if (!isSqlValue) {
+                val = JSON.stringify(val);
+            }
+            if (getJsonDialect(knex, key) === 'mysql') {
+                const empty = access[0].type === 'array' ? 'JSON_ARRAY()' : 'JSON_OBJECT()';
+                const column = isFirstSet ? `COALESCE(??, ${empty})` : '??';
+                const value = isSqlValue ? '?' : toJsonSql('?', knex);
+                convertedJson[parsed.column] = knex.raw(`JSON_SET(${column}, ?, ${value})`, [
+                    target,
+                    toMySqlJsonPath(access),
+                    val,
+                ]);
+            }
+            else {
+                const empty = access[0].type === 'array' ? `'[]'::jsonb` : `'{}'::jsonb`;
+                const column = isFirstSet ? `COALESCE(??, ${empty})` : '??';
+                const value = isSqlValue ? 'to_jsonb(?)' : '?';
+                convertedJson[parsed.column] = knex.raw(`jsonb_set(${column}, ${toPgJsonPathLiteral(access)}, ${value}, true)`, [target, val]);
+            }
+            delete model[key];
+        }
+        else {
+            convertedJson[key] = val;
+        }
     }
-  }
-
-  return convertedJson;
+    return convertedJson;
 }
-
 module.exports = {
-  UpdateOperation,
-  convertFieldExpressionsToRaw,
+    UpdateOperation,
+    convertFieldExpressionsToRaw,
 };

package/lib/queryBuilder/operations/UpsertGraphAndFetchOperation.js

@@ -1,45 +1,35 @@
 'use strict';
-
 const { DelegateOperation } = require('./DelegateOperation');
 const { UpsertGraphOperation } = require('./UpsertGraphOperation');
 const { RelationExpression } = require('../RelationExpression');
-
 class UpsertGraphAndFetchOperation extends DelegateOperation {
-  constructor(name, opt) {
-    super(name, opt);
-
-    if (!this.delegate.is(UpsertGraphOperation)) {
-      throw new Error('Invalid delegate');
+    constructor(name, opt) {
+        super(name, opt);
+        if (!this.delegate.is(UpsertGraphOperation)) {
+            throw new Error('Invalid delegate');
+        }
     }
-  }
-
-  get models() {
-    return this.delegate.models;
-  }
-
-  get isArray() {
-    return this.delegate.isArray;
-  }
-
-  async onAfter3(builder) {
-    if (this.models.length === 0) {
-      return this.isArray ? [] : null;
+    get models() {
+        return this.delegate.models;
+    }
+    get isArray() {
+        return this.delegate.isArray;
+    }
+    async onAfter3(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 = {
-  UpsertGraphAndFetchOperation,
+    UpsertGraphAndFetchOperation,
 };