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

package/lib/queryBuilder/operations/select/SelectOperation.js

@@ -1,66 +1,50 @@
 'use strict';
-
 const { flatten } = require('../../../utils/objectUtils');
 const { Selection } = require('./Selection');
 const { ObjectionToKnexConvertingOperation } = require('../ObjectionToKnexConvertingOperation');
-
 const COUNT_REGEX = /count/i;
-
 class SelectOperation extends ObjectionToKnexConvertingOperation {
-  constructor(name, opt) {
-    super(name, opt);
-    this.selections = [];
-  }
-
-  onAdd(builder, args) {
-    const selections = flatten(args);
-
-    // Don't add an empty selection. Empty list is accepted for `count`, `countDistinct`
-    // etc. because knex apparently supports it.
-    if (selections.length === 0 && !COUNT_REGEX.test(this.name)) {
-      return false;
+    constructor(name, opt) {
+        super(name, opt);
+        this.selections = [];
     }
-
-    const ret = super.onAdd(builder, selections);
-
-    for (const selection of selections) {
-      const selectionInstance = Selection.create(selection);
-
-      if (selectionInstance) {
-        this.selections.push(selectionInstance);
-      }
+    onAdd(builder, args) {
+        const selections = flatten(args);
+        // Don't add an empty selection. Empty list is accepted for `count`, `countDistinct`
+        // etc. because knex apparently supports it.
+        if (selections.length === 0 && !COUNT_REGEX.test(this.name)) {
+            return false;
+        }
+        const ret = super.onAdd(builder, selections);
+        for (const selection of selections) {
+            const selectionInstance = Selection.create(selection);
+            if (selectionInstance) {
+                this.selections.push(selectionInstance);
+            }
+        }
+        return ret;
     }
-
-    return ret;
-  }
-
-  onBuildKnex(knexBuilder, builder) {
-    return knexBuilder[this.name].apply(knexBuilder, this.getKnexArgs(builder));
-  }
-
-  findSelection(builder, selectionToFind) {
-    const selectionInstanceToFind = Selection.create(selectionToFind);
-
-    if (!selectionInstanceToFind) {
-      return null;
+    onBuildKnex(knexBuilder, builder) {
+        return knexBuilder[this.name].apply(knexBuilder, this.getKnexArgs(builder));
     }
-
-    for (const selection of this.selections) {
-      if (Selection.doesSelect(builder, selection, selectionInstanceToFind)) {
-        return selection;
-      }
+    findSelection(builder, selectionToFind) {
+        const selectionInstanceToFind = Selection.create(selectionToFind);
+        if (!selectionInstanceToFind) {
+            return null;
+        }
+        for (const selection of this.selections) {
+            if (Selection.doesSelect(builder, selection, selectionInstanceToFind)) {
+                return selection;
+            }
+        }
+        return null;
+    }
+    clone() {
+        const clone = super.clone();
+        clone.selections = this.selections.slice();
+        return clone;
     }
-
-    return null;
-  }
-
-  clone() {
-    const clone = super.clone();
-    clone.selections = this.selections.slice();
-    return clone;
-  }
 }
-
 module.exports = {
-  SelectOperation,
+    SelectOperation,
 };

package/lib/queryBuilder/operations/select/Selection.js

@@ -1,123 +1,112 @@
 'use strict';
-
 const { isString, isObject } = require('../../../utils/objectUtils');
-
 const ALIAS_REGEX = /\s+as\s+/i;
-
 class Selection {
-  constructor(table, column, alias) {
-    this.table = table;
-    this.column = column;
-    this.alias = alias;
-  }
-
-  get name() {
-    return this.alias || this.column;
-  }
-
-  static create(selection) {
-    if (isObject(selection)) {
-      if (selection.isObjectionSelection) {
-        return selection;
-      } else if (selection.isObjectionReferenceBuilder) {
-        return createSelectionFromReference(selection);
-      } else if (selection.isObjectionRawBuilder) {
-        return createSelectionFromRaw(selection);
-      } else {
-        return null;
-      }
-    } else if (isString(selection)) {
-      return createSelectionFromString(selection);
-    } else {
-      return null;
+    constructor(table, column, alias) {
+        this.table = table;
+        this.column = column;
+        this.alias = alias;
+    }
+    get name() {
+        return this.alias || this.column;
     }
-  }
-
-  /**
-   * Returns true if `selectionInBuilder` causes `selectionToTest` to be selected.
-   *
-   * Examples that return true:
-   *
-   * doesSelect(Person.query(), '*', 'name')
-   * doesSelect(Person.query(), 'Person.*', 'name')
-   * doesSelect(Person.query(), 'name', 'name')
-   * doesSelect(Person.query(), 'name', 'Person.name')
-   */
-  static doesSelect(builder, selectionInBuilder, selectionToTest) {
-    selectionInBuilder = Selection.create(selectionInBuilder);
-    selectionToTest = Selection.create(selectionToTest);
-
-    if (selectionInBuilder.column === '*') {
-      if (selectionInBuilder.table) {
-        if (selectionToTest.column === '*') {
-          return selectionToTest.table === selectionInBuilder.table;
-        } else {
-          return (
-            selectionToTest.table === null || selectionToTest.table === selectionInBuilder.table
-          );
+    static create(selection) {
+        if (isObject(selection)) {
+            if (selection.isObjectionSelection) {
+                return selection;
+            }
+            else if (selection.isObjectionReferenceBuilder) {
+                return createSelectionFromReference(selection);
+            }
+            else if (selection.isObjectionRawBuilder) {
+                return createSelectionFromRaw(selection);
+            }
+            else {
+                return null;
+            }
+        }
+        else if (isString(selection)) {
+            return createSelectionFromString(selection);
+        }
+        else {
+            return null;
+        }
+    }
+    /**
+     * Returns true if `selectionInBuilder` causes `selectionToTest` to be selected.
+     *
+     * Examples that return true:
+     *
+     * doesSelect(Person.query(), '*', 'name')
+     * doesSelect(Person.query(), 'Person.*', 'name')
+     * doesSelect(Person.query(), 'name', 'name')
+     * doesSelect(Person.query(), 'name', 'Person.name')
+     */
+    static doesSelect(builder, selectionInBuilder, selectionToTest) {
+        selectionInBuilder = Selection.create(selectionInBuilder);
+        selectionToTest = Selection.create(selectionToTest);
+        if (selectionInBuilder.column === '*') {
+            if (selectionInBuilder.table) {
+                if (selectionToTest.column === '*') {
+                    return selectionToTest.table === selectionInBuilder.table;
+                }
+                else {
+                    return (selectionToTest.table === null || selectionToTest.table === selectionInBuilder.table);
+                }
+            }
+            else {
+                return true;
+            }
+        }
+        else {
+            const selectionInBuilderTable = selectionInBuilder.table || builder.tableRef();
+            if (selectionToTest.column === '*') {
+                return false;
+            }
+            else {
+                return (selectionToTest.column === selectionInBuilder.column &&
+                    (selectionToTest.table === null || selectionToTest.table === selectionInBuilderTable));
+            }
         }
-      } else {
-        return true;
-      }
-    } else {
-      const selectionInBuilderTable = selectionInBuilder.table || builder.tableRef();
-
-      if (selectionToTest.column === '*') {
-        return false;
-      } else {
-        return (
-          selectionToTest.column === selectionInBuilder.column &&
-          (selectionToTest.table === null || selectionToTest.table === selectionInBuilderTable)
-        );
-      }
     }
-  }
 }
-
 Object.defineProperties(Selection.prototype, {
-  isObjectionSelection: {
-    enumerable: false,
-    writable: false,
-    value: true,
-  },
+    isObjectionSelection: {
+        enumerable: false,
+        writable: false,
+        value: true,
+    },
 });
-
 function createSelectionFromReference(ref) {
-  return new Selection(ref.tableName, ref.column, ref.alias);
+    return new Selection(ref.tableName, ref.column, ref.alias);
 }
-
 function createSelectionFromRaw(raw) {
-  if (raw.alias) {
-    return new Selection(null, null, raw.alias);
-  } else {
-    return null;
-  }
+    if (raw.alias) {
+        return new Selection(null, null, raw.alias);
+    }
+    else {
+        return null;
+    }
 }
-
 function createSelectionFromString(selection) {
-  let table = null;
-  let column = null;
-  let alias = null;
-
-  if (ALIAS_REGEX.test(selection)) {
-    const parts = selection.split(ALIAS_REGEX);
-
-    selection = parts[0].trim();
-    alias = parts[1].trim();
-  }
-
-  const dotIdx = selection.lastIndexOf('.');
-
-  if (dotIdx !== -1) {
-    table = selection.substr(0, dotIdx);
-    column = selection.substr(dotIdx + 1);
-  } else {
-    column = selection;
-  }
-
-  return new Selection(table, column, alias);
+    let table = null;
+    let column = null;
+    let alias = null;
+    if (ALIAS_REGEX.test(selection)) {
+        const parts = selection.split(ALIAS_REGEX);
+        selection = parts[0].trim();
+        alias = parts[1].trim();
+    }
+    const dotIdx = selection.lastIndexOf('.');
+    if (dotIdx !== -1) {
+        table = selection.substr(0, dotIdx);
+        column = selection.substr(dotIdx + 1);
+    }
+    else {
+        column = selection;
+    }
+    return new Selection(table, column, alias);
 }
-
 module.exports = {
-  Selection,
+    Selection,
 };

package/lib/queryBuilder/operations/whereInComposite/WhereInCompositeMsSqlOperation.js

@@ -1,117 +1,84 @@
 'use strict';
-
 const { ObjectionToKnexConvertingOperation } = require('../ObjectionToKnexConvertingOperation');
 const { flatten, zipObject, isString } = require('../../../utils/objectUtils');
 const { getTempColumn } = require('../../../utils/tmpColumnUtils');
-
 class WhereInCompositeMsSqlOperation extends ObjectionToKnexConvertingOperation {
-  constructor(name, opt) {
-    super(name, opt);
-    this.prefix = this.opt.prefix || null;
-  }
-
-  onBuildKnex(knexBuilder, builder) {
-    const args = this.getKnexArgs(builder);
-    return this.build(builder.knex(), knexBuilder, args[0], args[1]);
-  }
-
-  build(knex, knexBuilder, columns, values) {
-    let isCompositeKey = Array.isArray(columns) && columns.length > 1;
-
-    if (isCompositeKey) {
-      return this.buildComposite(knex, knexBuilder, columns, values);
-    } else {
-      return this.buildNonComposite(knexBuilder, columns, values);
+    constructor(name, opt) {
+        super(name, opt);
+        this.prefix = this.opt.prefix || null;
     }
-  }
-
-  buildComposite(knex, knexBuilder, columns, values) {
-    const helperColumns = columns.map((_, index) => getTempColumn(index));
-
-    if (Array.isArray(values)) {
-      return this.buildCompositeValue(knex, knexBuilder, columns, helperColumns, values);
-    } else {
-      return this.buildCompositeSubquery(
-        knex,
-        knexBuilder,
-        columns,
-        helperColumns,
-        values.as(knex.raw(`V(${helperColumns.map((_) => '??')})`, helperColumns)),
-      );
+    onBuildKnex(knexBuilder, builder) {
+        const args = this.getKnexArgs(builder);
+        return this.build(builder.knex(), knexBuilder, args[0], args[1]);
     }
-  }
-
-  buildCompositeValue(knex, knexBuilder, columns, helperColumns, values) {
-    return this.buildCompositeSubquery(
-      knex,
-      knexBuilder,
-      columns,
-      helperColumns,
-      knex.raw(
-        `(VALUES ${values
-          .map((value) => `(${value.map((_) => '?').join(',')})`)
-          .join(',')}) AS V(${helperColumns.map((_) => '??').join(',')})`,
-        flatten(values).concat(helperColumns),
-      ),
-    );
-  }
-
-  buildCompositeSubquery(knex, knexBuilder, columns, helperColumns, subQuery) {
-    const wrapperQuery = knex.from(subQuery).where(
-      zipObject(
-        helperColumns,
-        columns.map((column) => knex.raw('??', column)),
-      ),
-    );
-
-    if (this.prefix === 'not') {
-      return knexBuilder.whereNotExists(wrapperQuery);
-    } else {
-      return knexBuilder.whereExists(wrapperQuery);
+    build(knex, knexBuilder, columns, values) {
+        const isCompositeKey = Array.isArray(columns) && columns.length > 1;
+        if (isCompositeKey) {
+            return this.buildComposite(knex, knexBuilder, columns, values);
+        }
+        else {
+            return this.buildNonComposite(knexBuilder, columns, values);
+        }
     }
-  }
-
-  buildNonComposite(knexBuilder, columns, values) {
-    const col = isString(columns) ? columns : columns[0];
-
-    if (Array.isArray(values)) {
-      values = pickNonNull(values, []);
-    } else {
-      values = [values];
+    buildComposite(knex, knexBuilder, columns, values) {
+        const helperColumns = columns.map((_, index) => getTempColumn(index));
+        if (Array.isArray(values)) {
+            return this.buildCompositeValue(knex, knexBuilder, columns, helperColumns, values);
+        }
+        else {
+            return this.buildCompositeSubquery(knex, knexBuilder, columns, helperColumns, values.as(knex.raw(`V(${helperColumns.map((_) => '??')})`, helperColumns)));
+        }
     }
-
-    return this.whereIn(knexBuilder, col, values);
-  }
-
-  whereIn(knexBuilder, col, val) {
-    if (this.prefix === 'not') {
-      return knexBuilder.whereNotIn(col, val);
-    } else {
-      return knexBuilder.whereIn(col, val);
+    buildCompositeValue(knex, knexBuilder, columns, helperColumns, values) {
+        return this.buildCompositeSubquery(knex, knexBuilder, columns, helperColumns, knex.raw(`(VALUES ${values
+            .map((value) => `(${value.map((_) => '?').join(',')})`)
+            .join(',')}) AS V(${helperColumns.map((_) => '??').join(',')})`, flatten(values).concat(helperColumns)));
+    }
+    buildCompositeSubquery(knex, knexBuilder, columns, helperColumns, subQuery) {
+        const wrapperQuery = knex.from(subQuery).where(zipObject(helperColumns, columns.map((column) => knex.raw('??', column))));
+        if (this.prefix === 'not') {
+            return knexBuilder.whereNotExists(wrapperQuery);
+        }
+        else {
+            return knexBuilder.whereExists(wrapperQuery);
+        }
+    }
+    buildNonComposite(knexBuilder, columns, values) {
+        const col = isString(columns) ? columns : columns[0];
+        if (Array.isArray(values)) {
+            values = pickNonNull(values, []);
+        }
+        else {
+            values = [values];
+        }
+        return this.whereIn(knexBuilder, col, values);
+    }
+    whereIn(knexBuilder, col, val) {
+        if (this.prefix === 'not') {
+            return knexBuilder.whereNotIn(col, val);
+        }
+        else {
+            return knexBuilder.whereIn(col, val);
+        }
+    }
+    clone() {
+        const clone = super.clone();
+        clone.prefix = this.prefix;
+        return clone;
     }
-  }
-
-  clone() {
-    const clone = super.clone();
-    clone.prefix = this.prefix;
-    return clone;
-  }
 }
-
 function pickNonNull(values, output) {
-  for (let i = 0, l = values.length; i < l; ++i) {
-    const val = values[i];
-
-    if (Array.isArray(val)) {
-      pickNonNull(val, output);
-    } else if (val !== null && val !== undefined) {
-      output.push(val);
+    for (let i = 0, l = values.length; i < l; ++i) {
+        const val = values[i];
+        if (Array.isArray(val)) {
+            pickNonNull(val, output);
+        }
+        else if (val !== null && val !== undefined) {
+            output.push(val);
+        }
     }
-  }
-
-  return output;
+    return output;
 }
-
 module.exports = {
-  WhereInCompositeMsSqlOperation,
+    WhereInCompositeMsSqlOperation,
 };

package/lib/queryBuilder/operations/whereInComposite/WhereInCompositeOperation.js

@@ -1,100 +1,90 @@
 'use strict';
-
 const { ObjectionToKnexConvertingOperation } = require('../ObjectionToKnexConvertingOperation');
 const { isObject, asSingle } = require('../../../utils/objectUtils');
 const { isKnexQueryBuilder } = require('../../../utils/knexUtils');
-
 class WhereInCompositeOperation extends ObjectionToKnexConvertingOperation {
-  constructor(name, opt) {
-    super(name, opt);
-    this.prefix = this.opt.prefix || null;
-  }
-
-  onBuildKnex(knexBuilder, builder) {
-    const whereInArgs = buildWhereInArgs(builder.knex(), ...this.getKnexArgs(builder));
-
-    if (this.prefix === 'not') {
-      return knexBuilder.whereNotIn(...whereInArgs);
-    } else {
-      return knexBuilder.whereIn(...whereInArgs);
+    constructor(name, opt) {
+        super(name, opt);
+        this.prefix = this.opt.prefix || null;
+    }
+    onBuildKnex(knexBuilder, builder) {
+        const whereInArgs = buildWhereInArgs(builder.knex(), ...this.getKnexArgs(builder));
+        if (this.prefix === 'not') {
+            return knexBuilder.whereNotIn(...whereInArgs);
+        }
+        else {
+            return knexBuilder.whereIn(...whereInArgs);
+        }
+    }
+    clone() {
+        const clone = super.clone();
+        clone.prefix = this.prefix;
+        return clone;
     }
-  }
-
-  clone() {
-    const clone = super.clone();
-    clone.prefix = this.prefix;
-    return clone;
-  }
 }
-
 function buildWhereInArgs(knex, columns, values) {
-  if (isCompositeKey(columns)) {
-    return buildCompositeArgs(knex, columns, values);
-  } else {
-    return buildNonCompositeArgs(columns, values);
-  }
+    if (isCompositeKey(columns)) {
+        return buildCompositeArgs(knex, columns, values);
+    }
+    else {
+        return buildNonCompositeArgs(columns, values);
+    }
 }
-
 function isCompositeKey(columns) {
-  return Array.isArray(columns) && columns.length > 1;
+    return Array.isArray(columns) && columns.length > 1;
 }
-
 function buildCompositeArgs(knex, columns, values) {
-  if (Array.isArray(values)) {
-    return buildCompositeValueArgs(columns, values);
-  } else {
-    return buildCompositeSubqueryArgs(knex, columns, values);
-  }
+    if (Array.isArray(values)) {
+        return buildCompositeValueArgs(columns, values);
+    }
+    else {
+        return buildCompositeSubqueryArgs(knex, columns, values);
+    }
 }
-
 function buildCompositeValueArgs(columns, values) {
-  if (!Array.isArray(values[0])) {
-    return [columns, [values]];
-  } else {
-    return [columns, values];
-  }
+    if (!Array.isArray(values[0])) {
+        return [columns, [values]];
+    }
+    else {
+        return [columns, values];
+    }
 }
-
 function buildCompositeSubqueryArgs(knex, columns, subquery) {
-  const sql = `(${columns
-    .map((col) => {
-      // On older versions of knex, raw doesn't work
-      // with `??`. We use `?` for those.
-      if (isObject(col)) {
-        return '?';
-      } else {
-        return '??';
-      }
+    const sql = `(${columns
+        .map((col) => {
+        // On older versions of knex, raw doesn't work
+        // with `??`. We use `?` for those.
+        if (isObject(col)) {
+            return '?';
+        }
+        else {
+            return '??';
+        }
     })
-    .join(',')})`;
-
-  return [knex.raw(sql, columns), subquery];
+        .join(',')})`;
+    return [knex.raw(sql, columns), subquery];
 }
-
 function buildNonCompositeArgs(columns, values) {
-  if (Array.isArray(values)) {
-    values = pickNonNull(values, []);
-  } else if (!isKnexQueryBuilder(values)) {
-    values = [values];
-  }
-
-  return [asSingle(columns), values];
+    if (Array.isArray(values)) {
+        values = pickNonNull(values, []);
+    }
+    else if (!isKnexQueryBuilder(values)) {
+        values = [values];
+    }
+    return [asSingle(columns), values];
 }
-
 function pickNonNull(values, output) {
-  for (let i = 0, l = values.length; i < l; ++i) {
-    const val = values[i];
-
-    if (Array.isArray(val)) {
-      pickNonNull(val, output);
-    } else if (val !== null && val !== undefined) {
-      output.push(val);
+    for (let i = 0, l = values.length; i < l; ++i) {
+        const val = values[i];
+        if (Array.isArray(val)) {
+            pickNonNull(val, output);
+        }
+        else if (val !== null && val !== undefined) {
+            output.push(val);
+        }
     }
-  }
-
-  return output;
+    return output;
 }
-
 module.exports = {
-  WhereInCompositeOperation,
+    WhereInCompositeOperation,
 };