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

package/lib/utils/identifierMapping.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.snakeCaseKeys = exports.camelCaseKeys = void 0;
+exports.snakeCase = snakeCase;
+exports.camelCase = camelCase;
+exports.snakeCaseMappers = snakeCaseMappers;
+exports.knexSnakeCaseMappers = knexSnakeCaseMappers;
+exports.knexIdentifierMappers = knexIdentifierMappers;
+exports.knexIdentifierMapping = knexIdentifierMapping;
+const objectUtils_1 = require("./objectUtils");
+// Super fast memoize for single argument functions.
+function memoize(func) {
+    const cache = new Map();
+    return (input) => {
+        let output = cache.get(input);
+        if (output === undefined) {
+            output = func(input);
+            cache.set(input, output);
+        }
+        return output;
+    };
+}
+// camelCase to snake_case converter that also works with non-ascii characters
+// This is needed especially so that aliases containing the `:` character,
+// objection uses internally, work.
+function snakeCase(str, { upperCase = false, underscoreBeforeDigits = false, underscoreBetweenUppercaseLetters = false, } = {}) {
+    if (str.length === 0) {
+        return str;
+    }
+    const upper = str.toUpperCase();
+    const lower = str.toLowerCase();
+    let out = lower[0];
+    for (let i = 1, l = str.length; i < l; ++i) {
+        const char = str[i];
+        const prevChar = str[i - 1];
+        const upperChar = upper[i];
+        const prevUpperChar = upper[i - 1];
+        const lowerChar = lower[i];
+        const prevLowerChar = lower[i - 1];
+        // If underScoreBeforeDigits is true then, well, insert an underscore
+        // before digits :). Only the first digit gets an underscore if
+        // there are multiple.
+        if (underscoreBeforeDigits && isDigit(char) && !isDigit(prevChar)) {
+            out += '_' + char;
+            continue;
+        }
+        // Test if `char` is an upper-case character and that the character
+        // actually has different upper and lower case versions.
+        if (char === upperChar && upperChar !== lowerChar) {
+            const prevCharacterIsUppercase = prevChar === prevUpperChar && prevUpperChar !== prevLowerChar;
+            // If underscoreBetweenUppercaseLetters is true, we always place an underscore
+            // before consecutive uppercase letters (e.g. "fooBAR" becomes "foo_b_a_r").
+            // Otherwise, we don't (e.g. "fooBAR" becomes "foo_bar").
+            if (underscoreBetweenUppercaseLetters || !prevCharacterIsUppercase) {
+                out += '_' + lowerChar;
+            }
+            else {
+                out += lowerChar;
+            }
+        }
+        else {
+            out += char;
+        }
+    }
+    if (upperCase) {
+        return out.toUpperCase();
+    }
+    else {
+        return out;
+    }
+}
+// snake_case to camelCase converter that simply reverses
+// the actions done by `snakeCase` function.
+function camelCase(str, { upperCase = false } = {}) {
+    if (str.length === 0) {
+        return str;
+    }
+    if (upperCase && isAllUpperCaseSnakeCase(str)) {
+        // Only convert to lower case if the string is all upper
+        // case snake_case. This allowes camelCase strings to go
+        // through without changing.
+        str = str.toLowerCase();
+    }
+    let out = str[0];
+    for (let i = 1, l = str.length; i < l; ++i) {
+        const char = str[i];
+        const prevChar = str[i - 1];
+        if (char !== '_') {
+            if (prevChar === '_') {
+                out += char.toUpperCase();
+            }
+            else {
+                out += char;
+            }
+        }
+    }
+    return out;
+}
+function isAllUpperCaseSnakeCase(str) {
+    for (let i = 1, l = str.length; i < l; ++i) {
+        const char = str[i];
+        if (char !== '_' && char !== char.toUpperCase()) {
+            return false;
+        }
+    }
+    return true;
+}
+function isDigit(char) {
+    return char >= '0' && char <= '9';
+}
+// Returns a function that splits the inputs string into pieces using `separator`,
+// only calls `mapper` for the last part and concatenates the string back together.
+// If no separators are found, `mapper` is called for the entire string.
+function mapLastPart(mapper, separator) {
+    return (str) => {
+        if (!str)
+            return str;
+        const idx = str.lastIndexOf(separator);
+        const mapped = mapper(str.slice(idx + separator.length));
+        return str.slice(0, idx + separator.length) + mapped;
+    };
+}
+// Returns a function that takes an object as an input and maps the object's keys
+// using `mapper`. If the input is not an object, the input is returned unchanged.
+function keyMapper(mapper) {
+    return (obj) => {
+        if (!(0, objectUtils_1.isObject)(obj) || Array.isArray(obj)) {
+            return obj;
+        }
+        const keys = Object.keys(obj);
+        const out = {};
+        for (let i = 0, l = keys.length; i < l; ++i) {
+            const key = keys[i];
+            out[mapper(key)] = obj[key];
+        }
+        return out;
+    };
+}
+function snakeCaseMappers(opt = {}) {
+    return {
+        parse: keyMapper(memoize((str) => camelCase(str, opt))),
+        format: keyMapper(memoize((str) => snakeCase(str, opt))),
+    };
+}
+function knexIdentifierMappers({ parse, format, idSeparator = ':', } = {}) {
+    // Without `parse` or `format`, the mappers throw when they're used, as they
+    // did in the JavaScript code.
+    const formatId = memoize(mapLastPart(format, idSeparator));
+    const parseId = memoize(mapLastPart(parse, idSeparator));
+    const parseKeys = keyMapper(parseId);
+    return {
+        wrapIdentifier(identifier, origWrap) {
+            return origWrap(formatId(identifier));
+        },
+        postProcessResponse(result) {
+            if (Array.isArray(result)) {
+                const output = new Array(result.length);
+                for (let i = 0, l = result.length; i < l; ++i) {
+                    output[i] = parseKeys(result[i]);
+                }
+                return output;
+            }
+            else {
+                return parseKeys(result);
+            }
+        },
+    };
+}
+function knexSnakeCaseMappers(opt = {}) {
+    return knexIdentifierMappers({
+        parse: (str) => camelCase(str, opt),
+        format: (str) => snakeCase(str, opt),
+    });
+}
+function knexIdentifierMapping(colToProp) {
+    const propToCol = Object.keys(colToProp).reduce((propToCol, column) => {
+        propToCol[colToProp[column]] = column;
+        return propToCol;
+    }, {});
+    return knexIdentifierMappers({
+        parse: (column) => colToProp[column] || column,
+        format: (prop) => propToCol[prop] || prop,
+    });
+}
+const camelCaseKeys = keyMapper(memoize(camelCase));
+exports.camelCaseKeys = camelCaseKeys;
+const snakeCaseKeys = keyMapper(memoize(snakeCase));
+exports.snakeCaseKeys = snakeCaseKeys;

package/lib/utils/internalPropUtils.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInternalProp = isInternalProp;
+const INTERNAL_PROP_PREFIX = '$';
+function isInternalProp(propName) {
+    return propName[0] === INTERNAL_PROP_PREFIX;
+}

package/lib/utils/knexUtils.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDialect = getDialect;
+exports.isPostgres = isPostgres;
+exports.isMySql = isMySql;
+exports.isMariaDb = isMariaDb;
+exports.getMariaDbVersion = getMariaDbVersion;
+exports.isSqlite = isSqlite;
+exports.isMsSql = isMsSql;
+exports.isOracle = isOracle;
+exports.isKnexQueryBuilder = isKnexQueryBuilder;
+exports.isKnexJoinBuilder = isKnexJoinBuilder;
+exports.isKnexRaw = isKnexRaw;
+const objectUtils_1 = require("../utils/objectUtils");
+function getDialect(knex) {
+    const type = typeof knex;
+    const knexLike = knex;
+    return ((knex !== null &&
+        (type === 'object' || type === 'function') &&
+        knexLike.client &&
+        knexLike.client.dialect) ||
+        null);
+}
+function isPostgres(knex) {
+    return getDialect(knex) === 'postgresql';
+}
+function isOracle(knex) {
+    const dialect = getDialect(knex);
+    return dialect === 'oracledb';
+}
+function isMySql(knex) {
+    const dialect = getDialect(knex);
+    return dialect === 'mysql' || dialect === 'mysql2';
+}
+// knex reports MariaDB as the `mysql` dialect. It's recognized from knex's
+// `mariadb` client, or from a `version` like '11.4.0-MariaDB' in the knex config
+// when the mysql2 driver is used. knex finds out about MariaDB itself only
+// after connecting, which would build the first queries differently than the
+// later ones, so that isn't used.
+function isMariaDb(knex) {
+    if (!isMySql(knex)) {
+        return false;
+    }
+    // isMySql() returned true, so the client exists.
+    const client = knex.client;
+    return client.driverName === 'mariadb' || /mariadb/i.test(configVersion(client));
+}
+// The MariaDB version as [major, minor], when it's known from the knex config.
+function getMariaDbVersion(knex) {
+    if (!isMariaDb(knex)) {
+        return null;
+    }
+    const match = /^(\d+)\.(\d+)/.exec(configVersion(knex.client));
+    return match ? [Number(match[1]), Number(match[2])] : null;
+}
+function configVersion(client) {
+    const version = client.config && client.config.version;
+    return typeof version === 'string' ? version : '';
+}
+function isSqlite(knex) {
+    return getDialect(knex) === 'sqlite3';
+}
+function isMsSql(knex) {
+    return getDialect(knex) === 'mssql';
+}
+function isKnexQueryBuilder(value) {
+    return (hasConstructor(value) &&
+        (0, objectUtils_1.isFunction)(value.select) &&
+        (0, objectUtils_1.isFunction)(value.column) &&
+        value.select === value.column &&
+        'client' in value);
+}
+function isKnexJoinBuilder(value) {
+    return hasConstructor(value) && value.grouping === 'join' && 'joinType' in value;
+}
+function isKnexRaw(value) {
+    return hasConstructor(value) && value.isRawInstance && 'client' in value;
+}
+function hasConstructor(value) {
+    return (0, objectUtils_1.isObject)(value) && (0, objectUtils_1.isFunction)(value.constructor);
+}

package/lib/utils/mixin.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compose = compose;
+exports.mixin = mixin;
+const objectUtils_1 = require("./objectUtils");
+function mixin(...mixinArgs) {
+    const args = (0, objectUtils_1.flatten)(mixinArgs);
+    const mixins = args.slice(1);
+    return mixins.reduce((Class, mixinFunc) => {
+        return mixinFunc(Class);
+    }, args[0]);
+}
+function compose(...composeArgs) {
+    const mixins = (0, objectUtils_1.flatten)(composeArgs);
+    return function (Class) {
+        return mixin(Class, mixins);
+    };
+}

package/lib/utils/mysqlJsonPath.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSON_CAST = void 0;
+exports.toMySqlJsonPath = toMySqlJsonPath;
+exports.toMySqlCastType = toMySqlCastType;
+exports.isBooleanType = isBooleanType;
+exports.toJsonSql = toJsonSql;
+exports.jsonCastsForDialect = jsonCastsForDialect;
+const knexUtils_1 = require("./knexUtils");
+// SQL types of `ReferenceBuilder` casts that MySQL's `CAST()` calls differently.
+// `CAST(x AS integer)` for example is a syntax error on MySQL.
+const MYSQL_CAST_TYPES = {
+    text: 'CHAR',
+    varchar: 'CHAR',
+    integer: 'SIGNED',
+    int: 'SIGNED',
+    smallint: 'SIGNED',
+    bigint: 'SIGNED',
+    float: 'FLOAT',
+    real: 'DOUBLE',
+    double: 'DOUBLE',
+    'double precision': 'DOUBLE',
+    decimal: 'DECIMAL(65,30)',
+    numeric: 'DECIMAL(65,30)',
+    json: 'JSON',
+    jsonb: 'JSON',
+};
+/**
+ * Converts the `access` part of a parsed field expression into a MySQL JSON
+ * path like `$."a"[1]."b.c"`. Keys are always quoted, so they can contain any
+ * characters. The path must be passed to MySQL as a binding.
+ */
+function toMySqlJsonPath(access) {
+    return ('$' +
+        access
+            .map((it) => {
+            if (it.type === 'array' && Number.isInteger(it.ref)) {
+                return `[${it.ref}]`;
+            }
+            else {
+                return `.${JSON.stringify(String(it.ref))}`;
+            }
+        })
+            .join(''));
+}
+function toMySqlCastType(sqlType) {
+    return MYSQL_CAST_TYPES[sqlType.toLowerCase()] || sqlType;
+}
+function isBooleanType(sqlType) {
+    const type = sqlType.toLowerCase();
+    return type === 'boolean' || type === 'bool';
+}
+// The SQL that makes `sql` a JSON value. MariaDB has no JSON type to cast to:
+// its JSON columns are text. `JSON_COMPACT()` returns the value as JSON, which
+// `JSON_SET()` nests instead of storing a string, and in the compact form
+// objection stores JSON in, so comparisons with columns work.
+function toJsonSql(sql, knex) {
+    return (0, knexUtils_1.isMariaDb)(knex) ? `JSON_COMPACT(${sql})` : `CAST(${sql} AS JSON)`;
+}
+const JSON_CAST = 'CAST(? AS JSON)';
+exports.JSON_CAST = JSON_CAST;
+// For SQL that objection generates before the knex instance is known, like the
+// conditions of the `whereJson*` methods: replaces `CAST(? AS JSON)` with
+// `JSON_COMPACT(?)` on MariaDB. The values are always bindings, so the text
+// only contains what objection generated.
+function jsonCastsForDialect(sql, knex) {
+    return (0, knexUtils_1.isMariaDb)(knex) && sql.includes(JSON_CAST)
+        ? sql.split(JSON_CAST).join('JSON_COMPACT(?)')
+        : sql;
+}

package/lib/utils/normalizeIds.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeIds = normalizeIds;
+const objectUtils_1 = require("../utils/objectUtils");
+function normalizeIds(ids, prop, opt) {
+    opt = opt || {};
+    const isComposite = prop.size > 1;
+    let ret;
+    if (isComposite) {
+        // For composite ids these are okay:
+        //
+        // 1. [1, 'foo', 4]
+        // 2. {a: 1, b: 'foo', c: 4}
+        // 3. [[1, 'foo', 4], [4, 'bar', 1]]
+        // 4. [{a: 1, b: 'foo', c: 4}, {a: 4, b: 'bar', c: 1}]
+        //
+        if (Array.isArray(ids)) {
+            if (Array.isArray(ids[0])) {
+                ret = new Array(ids.length);
+                // 3.
+                for (let i = 0, l = ids.length; i < l; ++i) {
+                    ret[i] = convertIdArrayToObject(ids[i], prop);
+                }
+            }
+            else if ((0, objectUtils_1.isObject)(ids[0])) {
+                ret = new Array(ids.length);
+                // 4.
+                for (let i = 0, l = ids.length; i < l; ++i) {
+                    ret[i] = ensureObject(ids[i]);
+                }
+            }
+            else {
+                // 1.
+                ret = [convertIdArrayToObject(ids, prop)];
+            }
+        }
+        else if ((0, objectUtils_1.isObject)(ids)) {
+            // 2.
+            ret = [ids];
+        }
+        else {
+            throw new Error(`invalid composite key ${JSON.stringify(ids)}`);
+        }
+    }
+    else {
+        // For non-composite ids, these are okay:
+        //
+        // 1. 1
+        // 2. {id: 1}
+        // 3. [1, 'foo', 4]
+        // 4. [{id: 1}, {id: 'foo'}, {id: 4}]
+        //
+        if (Array.isArray(ids)) {
+            if ((0, objectUtils_1.isObject)(ids[0])) {
+                ret = new Array(ids.length);
+                // 4.
+                for (let i = 0, l = ids.length; i < l; ++i) {
+                    ret[i] = ensureObject(ids[i]);
+                }
+            }
+            else {
+                ret = new Array(ids.length);
+                // 3.
+                for (let i = 0, l = ids.length; i < l; ++i) {
+                    ret[i] = {};
+                    prop.setProp(ret[i], 0, ids[i]);
+                }
+            }
+        }
+        else if ((0, objectUtils_1.isObject)(ids)) {
+            // 2.
+            ret = [ids];
+        }
+        else {
+            // 1.
+            const obj = {};
+            prop.setProp(obj, 0, ids);
+            ret = [obj];
+        }
+    }
+    checkProperties(ret, prop);
+    if (opt.arrayOutput) {
+        return normalizedToArray(ret, prop);
+    }
+    else {
+        return ret;
+    }
+}
+function convertIdArrayToObject(ids, prop) {
+    if (!Array.isArray(ids)) {
+        throw new Error(`invalid composite key ${JSON.stringify(ids)}`);
+    }
+    if (ids.length != prop.size) {
+        throw new Error(`composite identifier ${JSON.stringify(ids)} should have ${prop.size} values`);
+    }
+    const obj = {};
+    for (let i = 0; i < ids.length; ++i) {
+        prop.setProp(obj, i, ids[i]);
+    }
+    return obj;
+}
+function ensureObject(ids) {
+    if ((0, objectUtils_1.isObject)(ids)) {
+        return ids;
+    }
+    else {
+        throw new Error(`invalid composite key ${JSON.stringify(ids)}`);
+    }
+}
+function checkProperties(ret, prop) {
+    for (let i = 0, l = ret.length; i < l; ++i) {
+        const obj = ret[i];
+        for (let j = 0, lp = prop.size; j < lp; ++j) {
+            const val = prop.getProp(obj, j);
+            if (typeof val === 'undefined') {
+                throw new Error(`expected id ${JSON.stringify(obj)} to have property ${prop.propDescription(j)}`);
+            }
+        }
+    }
+}
+function normalizedToArray(ret, prop) {
+    const arr = new Array(ret.length);
+    for (let i = 0, l = ret.length; i < l; ++i) {
+        arr[i] = prop.getProps(ret[i]);
+    }
+    return arr;
+}