@abedmurrar/objection 0.0.0-stage → 4.0.0-alpha.0

package/lib/queryBuilder/operations/jsonApi/postgresJsonApi.js

@@ -0,0 +1,164 @@
+'use strict';
+
+const parser = require('../../../utils/parseFieldExpression');
+const { asArray, isObject, isString } = require('../../../utils/objectUtils');
+const { toPgJsonPathLiteral, toPgQuotedColumn } = require('../../../utils/postgresJsonPath');
+
+/**
+ * @typedef {String} FieldExpression
+ *
+ * Field expressions allow one to refer to separate JSONB fields inside columns.
+ *
+ * Syntax: <column reference>[:<json field reference>]
+ *
+ * e.g. `Person.jsonColumnName:details.names[1]` would refer to value `'Second'`
+ * in column `Person.jsonColumnName` which has
+ * `{ details: { names: ['First', 'Second', 'Last'] } }` object stored in it.
+ *
+ * First part `<column reference>` is compatible with column references used in
+ * knex e.g. `MyFancyTable.tributeToThBestColumnNameEver`.
+ *
+ * Second part describes a path to an attribute inside the referred column.
+ * It is optional and it always starts with colon which follows directly with
+ * first path element. e.g. `Table.jsonObjectColumnName:jsonFieldName` or
+ * `Table.jsonArrayColumn:[321]`.
+ *
+ * Syntax supports `[<key or index>]` and `.<key or index>` flavors of reference
+ * to json keys / array indexes:
+ *
+ * e.g. both `Table.myColumn:[1][3]` and `Table.myColumn:1.3` would access correctly
+ * both of the following objects `[null, [null,null,null, "I was accessed"]]` and
+ * `{ "1": { "3" : "I was accessed" } }`
+ *
+ * Caveats when using special characters in keys:
+ *
+ * 1. `objectColumn.key` This is the most common syntax, good if you are
+ *    not using dots or square brackets `[]` in your json object key name.
+ * 2. Keys containing dots `objectColumn:[keywith.dots]` Column `{ "keywith.dots" : "I was referred" }`
+ * 3. Keys containing square brackets `column['[]']` `{ "[]" : "This is getting ridiculous..." }`
+ * 4. Keys containing square brackets and quotes
+ *    `objectColumn:['Double."Quote".[]']` and `objectColumn:["Sinlge.'Quote'.[]"]`
+ *    Column `{ "Double.\"Quote\".[]" : "I was referred",  "Single.'Quote'.[]" : "Mee too!" }`
+ * 99. Keys containing dots, square brackets, single quotes and double quotes in one json key is
+ *     not currently supported
+ */
+
+function parseFieldExpression(expression, extractAsText) {
+  let parsed = parser.parseFieldExpression(expression);
+  let extractor = extractAsText ? '#>>' : '#>';
+  return `${toPgQuotedColumn(parsed.columnName)}${extractor}${toPgJsonPathLiteral(parsed.access)}`;
+}
+
+function whereJsonbRefOnLeftJsonbValOrRefOnRight(
+  builder,
+  fieldExpression,
+  operator,
+  jsonObjectOrFieldExpression,
+  queryPrefix,
+) {
+  let queryParams = whereJsonbRefOnLeftJsonbValOrRefOnRightRawQueryParams(
+    fieldExpression,
+    operator,
+    jsonObjectOrFieldExpression,
+    queryPrefix,
+  );
+  return builder.whereRaw.apply(builder, queryParams);
+}
+
+function whereJsonbRefOnLeftJsonbValOrRefOnRightRawQueryParams(
+  fieldExpression,
+  operator,
+  jsonObjectOrFieldExpression,
+  queryPrefix,
+) {
+  let fieldReference = parseFieldExpression(fieldExpression);
+
+  if (isString(jsonObjectOrFieldExpression)) {
+    let rightHandReference = parseFieldExpression(jsonObjectOrFieldExpression);
+    let refRefQuery = [
+      '(',
+      fieldReference,
+      ')::jsonb',
+      operator,
+      '(',
+      rightHandReference,
+      ')::jsonb',
+    ];
+    if (queryPrefix) {
+      refRefQuery.unshift(queryPrefix);
+    }
+    return [refRefQuery.join(' ')];
+  } else if (isObject(jsonObjectOrFieldExpression)) {
+    let refValQuery = ['(', fieldReference, ')::jsonb', operator, '?::jsonb'];
+    if (queryPrefix) {
+      refValQuery.unshift(queryPrefix);
+    }
+    return [refValQuery.join(' '), JSON.stringify(jsonObjectOrFieldExpression)];
+  }
+
+  throw new Error('Invalid right hand expression.');
+}
+
+function whereJsonFieldRightStringArrayOnLeftQuery(knex, fieldExpression, operator, keys) {
+  let fieldReference = parseFieldExpression(fieldExpression);
+  keys = asArray(keys);
+
+  let questionMarksArray = keys.map((key) => {
+    if (!isString(key)) {
+      throw new Error('All keys to find must be strings.');
+    }
+    return '?';
+  });
+
+  let rightHandExpression = 'array[' + questionMarksArray.join(',') + ']';
+
+  return [`${fieldReference} ${operator.replace('?', '\\?')} ${rightHandExpression}`, keys];
+}
+
+function whereJsonFieldQuery(knex, fieldExpression, operator, value) {
+  let fieldReference = parseFieldExpression(fieldExpression, true);
+  let normalizedOperator = normalizeOperator(knex, operator);
+
+  // json type comparison takes json type in string format
+  let cast;
+  let valuePlaceholder = '?';
+  let bindings = [value];
+  let type = typeof value;
+
+  if (type === 'number') {
+    cast = '::NUMERIC';
+  } else if (type === 'boolean') {
+    cast = '::BOOLEAN';
+  } else if (type === 'string') {
+    cast = '::TEXT';
+  } else if (value === null) {
+    cast = '::TEXT';
+    valuePlaceholder = 'NULL';
+    bindings = [];
+  } else {
+    throw new Error('Value must be string, number, boolean or null.');
+  }
+
+  return [`(${fieldReference})${cast} ${normalizedOperator} ${valuePlaceholder}`, bindings];
+}
+
+function normalizeOperator(knex, operator) {
+  let trimmedLowerCase = operator.trim().toLowerCase();
+
+  switch (trimmedLowerCase) {
+    case 'is':
+    case 'is not':
+      return trimmedLowerCase;
+    default:
+      return knex.client.formatter().operator(operator);
+  }
+}
+
+module.exports = {
+  parseFieldExpression: parseFieldExpression,
+  whereJsonbRefOnLeftJsonbValOrRefOnRight: whereJsonbRefOnLeftJsonbValOrRefOnRight,
+  whereJsonbRefOnLeftJsonbValOrRefOnRightRawQueryParams:
+    whereJsonbRefOnLeftJsonbValOrRefOnRightRawQueryParams,
+  whereJsonFieldRightStringArrayOnLeftQuery: whereJsonFieldRightStringArrayOnLeftQuery,
+  whereJsonFieldQuery: whereJsonFieldQuery,
+};

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

@@ -0,0 +1,66 @@
+'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;
+    }
+
+    const ret = super.onAdd(builder, selections);
+
+    for (const selection of selections) {
+      const selectionInstance = Selection.create(selection);
+
+      if (selectionInstance) {
+        this.selections.push(selectionInstance);
+      }
+    }
+
+    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;
+    }
+
+    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;
+  }
+}
+
+module.exports = {
+  SelectOperation,
+};

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

@@ -0,0 +1,123 @@
+'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;
+    }
+  }
+
+  /**
+   * 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)
+        );
+      }
+    }
+  }
+}
+
+Object.defineProperties(Selection.prototype, {
+  isObjectionSelection: {
+    enumerable: false,
+    writable: false,
+    value: true,
+  },
+});
+
+function createSelectionFromReference(ref) {
+  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;
+  }
+}
+
+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);
+}
+
+module.exports = {
+  Selection,
+};

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

@@ -0,0 +1,117 @@
+'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);
+    }
+  }
+
+  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)),
+      );
+    }
+  }
+
+  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;
+  }
+}
+
+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);
+    }
+  }
+
+  return output;
+}
+
+module.exports = {
+  WhereInCompositeMsSqlOperation,
+};

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

@@ -0,0 +1,100 @@
+'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);
+    }
+  }
+
+  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);
+  }
+}
+
+function isCompositeKey(columns) {
+  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);
+  }
+}
+
+function buildCompositeValueArgs(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 '??';
+      }
+    })
+    .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];
+}
+
+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);
+    }
+  }
+
+  return output;
+}
+
+module.exports = {
+  WhereInCompositeOperation,
+};

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

@@ -0,0 +1,104 @@
+'use strict';
+
+const { ObjectionToKnexConvertingOperation } = require('../ObjectionToKnexConvertingOperation');
+const { isKnexQueryBuilder } = require('../../../utils/knexUtils');
+const { asSingle } = require('../../../utils/objectUtils');
+
+class WhereInCompositeSqliteOperation extends ObjectionToKnexConvertingOperation {
+  constructor(name, opt) {
+    super(name, opt);
+    this.prefix = this.opt.prefix || null;
+  }
+
+  onBuildKnex(knexBuilder, builder) {
+    const { method, args } = buildWhereArgs(...this.getKnexArgs(builder));
+
+    if (method === 'where') {
+      if (this.prefix === 'not') {
+        return knexBuilder.whereNot(...args);
+      } else {
+        return knexBuilder.where(...args);
+      }
+    } else {
+      if (this.prefix === 'not') {
+        return knexBuilder.whereNotIn(...args);
+      } else {
+        return knexBuilder.whereIn(...args);
+      }
+    }
+  }
+
+  clone() {
+    const clone = super.clone();
+    clone.prefix = this.prefix;
+    return clone;
+  }
+}
+
+function buildWhereArgs(columns, values) {
+  if (isCompositeKey(columns)) {
+    return buildCompositeArgs(columns, values);
+  } else {
+    return buildNonCompositeArgs(columns, values);
+  }
+}
+
+function isCompositeKey(columns) {
+  return Array.isArray(columns) && columns.length > 1;
+}
+
+function buildCompositeArgs(columns, values) {
+  if (!Array.isArray(values)) {
+    // If the `values` is not an array of values but a function or a subquery
+    // we have no way to implement this method.
+    throw new Error(`sqlite doesn't support multi-column where in clauses`);
+  }
+
+  // Sqlite doesn't support the `where in` syntax for multiple columns but
+  // we can emulate it using grouped `or` clauses.
+  return {
+    method: 'where',
+    args: [
+      (builder) => {
+        values.forEach((val) => {
+          builder.orWhere((builder) => {
+            columns.forEach((col, idx) => {
+              builder.andWhere(col, val[idx]);
+            });
+          });
+        });
+      },
+    ],
+  };
+}
+
+function buildNonCompositeArgs(columns, values) {
+  if (Array.isArray(values)) {
+    values = pickNonNull(values, []);
+  } else if (!isKnexQueryBuilder(values)) {
+    values = [values];
+  }
+
+  return {
+    method: 'whereIn',
+    args: [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);
+    }
+  }
+
+  return output;
+}
+
+module.exports = {
+  WhereInCompositeSqliteOperation,
+};