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

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

@@ -0,0 +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;
+        }
+        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,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;
+        }
+    }
+    /**
+     * 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,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) {
+        const 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,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);
+        }
+    }
+    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,95 @@
+'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,
+};