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

package/lib/utils/objectUtils.js

@@ -0,0 +1,314 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cloneDeep = void 0;
+exports.isEmpty = isEmpty;
+exports.isString = isString;
+exports.isRegExp = isRegExp;
+exports.isObject = isObject;
+exports.isNumber = isNumber;
+exports.isFunction = isFunction;
+exports.jsonEquals = jsonEquals;
+exports.isPlainObject = isPlainObject;
+exports.difference = difference;
+exports.zipObject = zipObject;
+exports.mergeMaps = mergeMaps;
+exports.asSingle = asSingle;
+exports.asArray = asArray;
+exports.flatten = flatten;
+exports.groupBy = groupBy;
+exports.uniqBy = uniqBy;
+exports.union = union;
+exports.chunk = chunk;
+exports.omit = omit;
+exports.once = once;
+exports.last = last;
+exports.get = get;
+exports.set = set;
+const cloneDeep_1 = require("./cloneDeep");
+Object.defineProperty(exports, "cloneDeep", { enumerable: true, get: function () { return cloneDeep_1.cloneDeep; } });
+const SMALL_ARRAY_SIZE = 10;
+function isEmpty(item) {
+    if (Array.isArray(item) || Buffer.isBuffer(item)) {
+        return item.length === 0;
+    }
+    else if (isObject(item)) {
+        return Object.keys(item).length === 0;
+    }
+    else {
+        return true;
+    }
+}
+// The `T &` keeps an `any` argument `any`.
+function isObject(value) {
+    return value !== null && typeof value === 'object';
+}
+// Quick and dirty check if an object is a plain object and not
+// for example an instance of some class.
+function isPlainObject(value) {
+    return (isObject(value) &&
+        (!value.constructor || value.constructor === Object) &&
+        (!value.toString || value.toString === Object.prototype.toString));
+}
+function isFunction(value) {
+    return typeof value === 'function';
+}
+function isRegExp(value) {
+    return value instanceof RegExp;
+}
+function isString(value) {
+    return typeof value === 'string';
+}
+function isNumber(value) {
+    return typeof value === 'number';
+}
+function asArray(value) {
+    return Array.isArray(value) ? value : [value];
+}
+function asSingle(value) {
+    return Array.isArray(value) ? value[0] : value;
+}
+function uniqBy(items, keyGetter = null) {
+    const map = new Map();
+    for (let i = 0, l = items.length; i < l; ++i) {
+        const item = items[i];
+        const key = keyGetter !== null ? keyGetter(item) : item;
+        map.set(key, item);
+    }
+    return Array.from(map.values());
+}
+function groupBy(items, keyGetter = null) {
+    const groups = new Map();
+    for (const item of items) {
+        const key = keyGetter !== null ? keyGetter(item) : item;
+        let group = groups.get(key);
+        if (!group) {
+            group = [];
+            groups.set(key, group);
+        }
+        group.push(item);
+    }
+    return groups;
+}
+function omit(obj, keysToOmit) {
+    const keysToOmitArray = asArray(keysToOmit);
+    const keys = Object.keys(obj);
+    const out = {};
+    for (let i = 0, l = keys.length; i < l; ++i) {
+        const key = keys[i];
+        if (!keysToOmitArray.includes(key)) {
+            out[key] = obj[key];
+        }
+    }
+    return out;
+}
+function difference(arr1, arr2) {
+    const arr2Set = new Set(arr2);
+    const diff = [];
+    for (let i = 0; i < arr1.length; ++i) {
+        const value = arr1[i];
+        if (!arr2Set.has(value)) {
+            diff.push(value);
+        }
+    }
+    return diff;
+}
+function union(arr1, arr2) {
+    if (arr1.length < SMALL_ARRAY_SIZE && arr2.length < SMALL_ARRAY_SIZE) {
+        return unionSmall(arr1, arr2);
+    }
+    else {
+        return unionGeneric(arr1, arr2);
+    }
+}
+function unionSmall(arr1, arr2) {
+    const all = arr1.slice();
+    for (let i = 0, l = arr2.length; i < l; ++i) {
+        const item = arr2[i];
+        if (all.indexOf(item) === -1) {
+            all.push(item);
+        }
+    }
+    return all;
+}
+function unionGeneric(arr1, arr2) {
+    const all = new Set();
+    for (let i = 0; i < arr1.length; ++i) {
+        all.add(arr1[i]);
+    }
+    for (let i = 0; i < arr2.length; ++i) {
+        all.add(arr2[i]);
+    }
+    return Array.from(all);
+}
+function last(arr) {
+    return arr[arr.length - 1];
+}
+function once(func) {
+    let called = false;
+    let value;
+    return function (...args) {
+        if (called === false) {
+            called = true;
+            value = func.apply(this, args);
+        }
+        return value;
+    };
+}
+function flatten(arrays) {
+    const out = [];
+    for (let i = 0, l = arrays.length; i < l; ++i) {
+        const value = arrays[i];
+        if (Array.isArray(value)) {
+            for (let j = 0; j < value.length; ++j) {
+                out.push(value[j]);
+            }
+        }
+        else {
+            out.push(value);
+        }
+    }
+    return out;
+}
+function get(obj, path) {
+    for (let i = 0, l = path.length; i < l; ++i) {
+        const key = path[i];
+        if (!isObject(obj)) {
+            return undefined;
+        }
+        obj = obj[key];
+    }
+    return obj;
+}
+function set(obj, path, value) {
+    const inputObj = obj;
+    // `obj` walks down the path. It's indexed as is, like the JavaScript code
+    // did, so a non-object input throws the same way.
+    let current = obj;
+    for (let i = 0, l = path.length - 1; i < l; ++i) {
+        const key = path[i];
+        if (!isSafeKey(key)) {
+            return inputObj;
+        }
+        let child = current[key];
+        if (!isObject(child)) {
+            const nextKey = path[i + 1];
+            // isNaN() converts the key to a number, so '1' is a number and 'a' is not.
+            if (isNaN(nextKey)) {
+                child = {};
+            }
+            else {
+                child = [];
+            }
+            current[key] = child;
+        }
+        current = child;
+    }
+    if (path.length > 0 && isObject(current)) {
+        const key = path[path.length - 1];
+        if (isSafeKey(key)) {
+            current[key] = value;
+        }
+    }
+    return inputObj;
+}
+function zipObject(keys, values) {
+    const out = {};
+    for (let i = 0, l = keys.length; i < l; ++i) {
+        const key = keys[i];
+        if (isSafeKey(key)) {
+            out[key] = values[i];
+        }
+    }
+    return out;
+}
+function chunk(arr, chunkSize) {
+    const out = [];
+    for (let i = 0, l = arr.length; i < l; ++i) {
+        const item = arr[i];
+        if (out.length === 0 || out[out.length - 1].length === chunkSize) {
+            out.push([]);
+        }
+        out[out.length - 1].push(item);
+    }
+    return out;
+}
+function jsonEquals(val1, val2) {
+    return jsonEqualsBase(val1, val2, compareStrict);
+}
+function jsonEqualsBase(val1, val2, compare) {
+    if (val1 === val2) {
+        return true;
+    }
+    return jsonEqualsSlowPath(val1, val2, compare);
+}
+function jsonEqualsSlowPath(val1, val2, compare) {
+    const type1 = typeof val1;
+    const type2 = typeof val2;
+    const isNonNullObject1 = type1 === 'object' && !compare(val1, null);
+    const isNonNullObject2 = type2 === 'object' && !compare(val2, null);
+    if (isNonNullObject1 && isNonNullObject2) {
+        const isArray1 = Array.isArray(val1);
+        const isArray2 = Array.isArray(val2);
+        if (isArray1 && isArray2) {
+            return jsonEqualsArray(val1, val2, compare);
+        }
+        else if (!isArray1 && !isArray2) {
+            return jsonEqualsObject(val1, val2, compare);
+        }
+        else {
+            return false;
+        }
+    }
+    else if (isNonNullObject1 !== isNonNullObject2) {
+        return false;
+    }
+    else {
+        return compare(val1, val2);
+    }
+}
+function jsonEqualsArray(arr1, arr2, compare) {
+    if (arr1.length !== arr2.length) {
+        return false;
+    }
+    for (let i = 0, l = arr1.length; i < l; ++i) {
+        if (!jsonEqualsBase(arr1[i], arr2[i], compare)) {
+            return false;
+        }
+    }
+    return true;
+}
+function jsonEqualsObject(obj1, obj2, compare) {
+    if (obj1.constructor === Date && obj2.constructor === Date) {
+        return equalsDate(obj1, obj2);
+    }
+    const keys1 = Object.keys(obj1);
+    const keys2 = Object.keys(obj2);
+    if (keys1.length !== keys2.length) {
+        return false;
+    }
+    for (let i = 0, l = keys1.length; i < l; ++i) {
+        const key = keys1[i];
+        if (!jsonEqualsBase(obj1[key], obj2[key], compare)) {
+            return false;
+        }
+    }
+    return true;
+}
+function equalsDate(date1, date2) {
+    return date1.getTime() === date2.getTime();
+}
+function compareStrict(val1, val2) {
+    return val1 === val2;
+}
+function isSafeKey(key) {
+    return isNumber(key) || (isString(key) && key !== '__proto__');
+}
+function mergeMaps(map1, map2) {
+    const map = new Map(map1);
+    if (map2) {
+        for (const key of map2.keys()) {
+            map.set(key, map2.get(key));
+        }
+    }
+    return map;
+}

package/lib/utils/parseFieldExpression.js

@@ -0,0 +1,73 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFieldExpression = parseFieldExpression;
+const jsonFieldExpressionParser = __importStar(require("../queryBuilder/parsers/jsonFieldExpressionParser"));
+const cache = new Map();
+function parseFieldExpression(expr) {
+    let parsedExpr = cache.get(expr);
+    if (parsedExpr !== undefined) {
+        return parsedExpr;
+    }
+    else {
+        const parserOutput = jsonFieldExpressionParser.parse(expr);
+        parsedExpr = preprocessParsedExpression(parserOutput);
+        // We don't take a copy of the parsedExpr each time we
+        // use if from cache. Instead to make sure it's never
+        // mutated we deep-freeze it.
+        parsedExpr = freezeParsedExpr(parsedExpr);
+        cache.set(expr, parsedExpr);
+        return parsedExpr;
+    }
+}
+function preprocessParsedExpression(parsedExpr) {
+    const columnParts = parsedExpr.columnName.split('.').map((part) => part.trim());
+    parsedExpr.column = columnParts[columnParts.length - 1];
+    if (columnParts.length >= 2) {
+        parsedExpr.table = columnParts.slice(0, columnParts.length - 1).join('.');
+    }
+    else {
+        parsedExpr.table = null;
+    }
+    return parsedExpr;
+}
+function freezeParsedExpr(parsedExpr) {
+    for (const access of parsedExpr.access) {
+        Object.freeze(access);
+    }
+    Object.freeze(parsedExpr.access);
+    Object.freeze(parsedExpr);
+    return parsedExpr;
+}

package/lib/utils/postgresJsonPath.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toPgTextArray = toPgTextArray;
+exports.toPgStringLiteral = toPgStringLiteral;
+exports.toPgJsonPathLiteral = toPgJsonPathLiteral;
+exports.toPgQuotedColumn = toPgQuotedColumn;
+exports.getJsonDialect = getJsonDialect;
+const knexUtils_1 = require("./knexUtils");
+// Characters that force an element of a postgres text array literal to be
+// double quoted: the array syntax characters, whitespace and control chars.
+const ARRAY_ELEMENT_NEEDS_QUOTES = /[{}",\\\s\x00-\x1f\x7f]|^$|^null$/i;
+// Characters that can't appear as-is inside a plain '...' string literal
+// without depending on the `standard_conforming_strings` setting.
+const NEEDS_ESCAPE_STRING = /[\\\x00-\x1f\x7f]/;
+const POSTGRES_DIALECTS = ['postgresql', 'redshift'];
+const MYSQL_DIALECTS = ['mysql', 'mysql2'];
+/**
+ * Converts the `access` part of a parsed field expression into a postgres
+ * text array literal like `{a,b,1}`. Elements are quoted and escaped so that
+ * keys containing array syntax characters can't change the path.
+ */
+function toPgTextArray(access) {
+    const elements = access.map((it) => {
+        if (it.type === 'array' && Number.isInteger(it.ref)) {
+            return String(it.ref);
+        }
+        const ref = String(it.ref);
+        if (ARRAY_ELEMENT_NEEDS_QUOTES.test(ref)) {
+            return `"${ref.replace(/[\\"]/g, '\\$&')}"`;
+        }
+        else {
+            return ref;
+        }
+    });
+    return `{${elements.join(',')}}`;
+}
+/**
+ * Converts a string into a postgres string literal that is safe to embed
+ * into a knex raw query. Single quotes are doubled and `?` characters are
+ * escaped so that knex doesn't treat them as binding placeholders.
+ *
+ * If the string contains backslashes or control characters, an escape
+ * string literal `E'...'` with octal escapes is used. This way the result
+ * is the same regardless of `standard_conforming_strings` and no literal
+ * backslash ever ends up next to a `?` (knex would eat it).
+ */
+function toPgStringLiteral(str) {
+    let sql = str.replace(/'/g, "''");
+    if (NEEDS_ESCAPE_STRING.test(sql)) {
+        sql = sql.replace(/[\\\x00-\x1f\x7f]/g, (char) => {
+            return '\\' + char.charCodeAt(0).toString(8).padStart(3, '0');
+        });
+        sql = `E'${sql}'`;
+    }
+    else {
+        sql = `'${sql}'`;
+    }
+    return sql.replace(/\?/g, '\\?');
+}
+/**
+ * Converts the `access` part of a parsed field expression into a string
+ * literal that can be used as the right hand side of `#>`, `#>>` and as the
+ * path argument of `jsonb_set`.
+ */
+function toPgJsonPathLiteral(access) {
+    return toPgStringLiteral(toPgTextArray(access));
+}
+/**
+ * Quotes a (possibly table qualified) column name like `Table.column` as
+ * `"Table"."column"` for postgres.
+ */
+function toPgQuotedColumn(columnName) {
+    return columnName
+        .split('.')
+        .map((part) => `"${part.replace(/"/g, '""')}"`)
+        .join('.')
+        .replace(/\?/g, '\\?');
+}
+/**
+ * Returns the flavor of JSON SQL to generate for field expressions: `'postgres'`
+ * or `'mysql'`. Other databases throw, since postgres SQL is invalid at best and
+ * dangerous at worst there (on MySQL `#` starts a comment). `knex` can be null,
+ * when the query has no knex instance bound yet, in which case postgres is used.
+ */
+function getJsonDialect(knex, expression) {
+    const dialect = knex ? (0, knexUtils_1.getDialect)(knex) : null;
+    if (dialect === null || POSTGRES_DIALECTS.includes(dialect)) {
+        return 'postgres';
+    }
+    else if (MYSQL_DIALECTS.includes(dialect)) {
+        return 'mysql';
+    }
+    else {
+        throw new Error(`JSON field expressions are only supported on postgres and mysql. Tried to use "${expression}" with dialect "${dialect}".`);
+    }
+}

package/lib/utils/promiseUtils/after.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.after = after;
+const isPromise_1 = require("./isPromise");
+// Call `func` after `obj` has been resolved. Call `func` synchronously if
+// `obj` is not a promise for performance reasons.
+function after(obj, func) {
+    if ((0, isPromise_1.isPromise)(obj)) {
+        return obj.then(func);
+    }
+    else {
+        return func(obj);
+    }
+}

package/lib/utils/promiseUtils/afterReturn.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.afterReturn = afterReturn;
+const isPromise_1 = require("./isPromise");
+// Return `returnValue` after `obj` has been resolved. Return `returnValue`
+// synchronously if `obj` is not a promise for performance reasons.
+function afterReturn(obj, returnValue) {
+    if ((0, isPromise_1.isPromise)(obj)) {
+        return obj.then(() => returnValue);
+    }
+    else {
+        return returnValue;
+    }
+}

package/lib/utils/promiseUtils/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.try = exports.map = exports.mapAfterAllReturn = exports.afterReturn = exports.after = exports.isPromise = void 0;
+const isPromise_1 = require("./isPromise");
+Object.defineProperty(exports, "isPromise", { enumerable: true, get: function () { return isPromise_1.isPromise; } });
+const after_1 = require("./after");
+Object.defineProperty(exports, "after", { enumerable: true, get: function () { return after_1.after; } });
+const afterReturn_1 = require("./afterReturn");
+Object.defineProperty(exports, "afterReturn", { enumerable: true, get: function () { return afterReturn_1.afterReturn; } });
+const mapAfterAllReturn_1 = require("./mapAfterAllReturn");
+Object.defineProperty(exports, "mapAfterAllReturn", { enumerable: true, get: function () { return mapAfterAllReturn_1.mapAfterAllReturn; } });
+const map_1 = require("./map");
+Object.defineProperty(exports, "map", { enumerable: true, get: function () { return map_1.promiseMap; } });
+const try_1 = require("./try");
+Object.defineProperty(exports, "try", { enumerable: true, get: function () { return try_1.promiseTry; } });

package/lib/utils/promiseUtils/isPromise.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPromise = isPromise;
+const objectUtils_1 = require("../objectUtils");
+// The `T &` keeps an `any` argument `any`.
+function isPromise(obj) {
+    return (0, objectUtils_1.isObject)(obj) && (0, objectUtils_1.isFunction)(obj.then);
+}

package/lib/utils/promiseUtils/map.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promiseMap = promiseMap;
+const isPromise_1 = require("./isPromise");
+// Works like Bluebird.map.
+function promiseMap(items, mapper, opt) {
+    switch (items.length) {
+        case 0:
+            return mapZero();
+        case 1:
+            return mapOne(items, mapper);
+        default:
+            return mapMany(items, mapper, opt);
+    }
+}
+function mapZero() {
+    return Promise.resolve([]);
+}
+function mapOne(items, mapper) {
+    try {
+        const maybePromise = mapper(items[0], 0);
+        if ((0, isPromise_1.isPromise)(maybePromise)) {
+            return maybePromise.then(wrapArray);
+        }
+        else {
+            return Promise.resolve(wrapArray(maybePromise));
+        }
+    }
+    catch (err) {
+        return Promise.reject(err);
+    }
+}
+function wrapArray(item) {
+    return [item];
+}
+function mapMany(items, mapper, opt = {}) {
+    return new Promise((resolve, reject) => {
+        const concurrency = opt.concurrency || Number.MAX_SAFE_INTEGER;
+        const ctx = {
+            reject,
+            resolve,
+            rejected: false,
+            index: 0,
+            numFinished: 0,
+            results: new Array(items.length),
+            items,
+            mapper,
+        };
+        while (ctx.index < concurrency && ctx.index < items.length && !ctx.rejected) {
+            executeNext(ctx);
+        }
+    });
+}
+function executeNext(ctx) {
+    try {
+        if (ctx.rejected) {
+            return;
+        }
+        const index = ctx.index++;
+        const item = ctx.items[index];
+        const maybePromise = ctx.mapper(item, index);
+        if ((0, isPromise_1.isPromise)(maybePromise)) {
+            // `catch` is called on the result of `then`, so the value is used as a
+            // promise. Promises and query builders have both.
+            maybePromise
+                .then((result) => afterExecute(ctx, result, index))
+                .catch((err) => onError(ctx, err));
+        }
+        else {
+            process.nextTick(() => afterExecute(ctx, maybePromise, index));
+        }
+        return null;
+    }
+    catch (err) {
+        onError(ctx, err);
+        return undefined;
+    }
+}
+function afterExecute(ctx, result, index) {
+    if (ctx.rejected) {
+        return null;
+    }
+    ctx.results[index] = result;
+    ctx.numFinished++;
+    if (ctx.numFinished === ctx.items.length) {
+        ctx.resolve(ctx.results);
+    }
+    if (ctx.index < ctx.items.length) {
+        executeNext(ctx);
+    }
+    return null;
+}
+function onError(ctx, err) {
+    ctx.rejected = true;
+    ctx.reject(err);
+}

package/lib/utils/promiseUtils/mapAfterAllReturn.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapAfterAllReturn = mapAfterAllReturn;
+const isPromise_1 = require("./isPromise");
+// Map `arr` with `mapper` and after that return `returnValue`. If none of
+// the mapped values is a promise, return synchronously for performance
+// reasons.
+function mapAfterAllReturn(arr, mapper, returnValue) {
+    const results = new Array(arr.length);
+    let containsPromise = false;
+    for (let i = 0, l = arr.length; i < l; ++i) {
+        results[i] = mapper(arr[i]);
+        if ((0, isPromise_1.isPromise)(results[i])) {
+            containsPromise = true;
+        }
+    }
+    if (containsPromise) {
+        return Promise.all(results).then(() => returnValue);
+    }
+    else {
+        return returnValue;
+    }
+}

package/lib/utils/promiseUtils/try.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promiseTry = promiseTry;
+const isPromise_1 = require("./isPromise");
+// Works like Bluebird.try.
+function promiseTry(callback) {
+    try {
+        const maybePromise = callback();
+        if ((0, isPromise_1.isPromise)(maybePromise)) {
+            return maybePromise;
+        }
+        else {
+            return Promise.resolve(maybePromise);
+        }
+    }
+    catch (err) {
+        return Promise.reject(err);
+    }
+}