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

package/lib/utils/identifierMapping.js

@@ -1,227 +1,188 @@
-'use strict';
-
-const { isObject } = require('./objectUtils');
-
+"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;
-  };
+    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;
+function snakeCase(str, { upperCase = false, underscoreBeforeDigits = false, underscoreBetweenUppercaseLetters = false, } = {}) {
+    if (str.length === 0) {
+        return str;
     }
-
-    // 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;
+    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;
     }
-  }
-
-  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;
-      }
+    if (str.length === 0) {
+        return str;
     }
-  }
-
-  return out;
+    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;
+    for (let i = 1, l = str.length; i < l; ++i) {
+        const char = str[i];
+        if (char !== '_' && char !== char.toUpperCase()) {
+            return false;
+        }
     }
-  }
-
-  return true;
+    return true;
 }
-
 function isDigit(char) {
-  return char >= '0' && char <= '9';
+    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;
-  };
+    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 (!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;
-  };
+    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))),
-  };
+    return {
+        parse: keyMapper(memoize((str) => camelCase(str, opt))),
+        format: keyMapper(memoize((str) => snakeCase(str, opt))),
+    };
 }
-
-function knexIdentifierMappers({ parse, format, idSeparator = ':' } = {}) {
-  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 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),
-  });
+    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 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,
+    });
 }
-
-module.exports = {
-  snakeCase,
-  camelCase,
-  snakeCaseMappers,
-  knexSnakeCaseMappers,
-  knexIdentifierMappers,
-  knexIdentifierMapping,
-
-  camelCaseKeys: keyMapper(memoize(camelCase)),
-  snakeCaseKeys: keyMapper(memoize(snakeCase)),
-};
+const camelCaseKeys = keyMapper(memoize(camelCase));
+exports.camelCaseKeys = camelCaseKeys;
+const snakeCaseKeys = keyMapper(memoize(snakeCase));
+exports.snakeCaseKeys = snakeCaseKeys;

package/lib/utils/internalPropUtils.js

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

package/lib/utils/knexUtils.js

@@ -1,76 +1,81 @@
-'use strict';
-
-const { isObject, isFunction } = require('../utils/objectUtils');
-
+"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;
-
-  return (
-    (knex !== null &&
-      (type === 'object' || type === 'function') &&
-      knex.client &&
-      knex.client.dialect) ||
-    null
-  );
+    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';
+    return getDialect(knex) === 'postgresql';
 }
-
 function isOracle(knex) {
-  const dialect = getDialect(knex);
-  return dialect === 'oracle' || dialect === 'oracledb';
+    const dialect = getDialect(knex);
+    return dialect === 'oracledb';
 }
-
 function isMySql(knex) {
-  const dialect = getDialect(knex);
-  return dialect === 'mysql' || dialect === 'mysql2';
+    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';
+    return getDialect(knex) === 'sqlite3';
 }
-
 function isMsSql(knex) {
-  return getDialect(knex) === 'mssql';
+    return getDialect(knex) === 'mssql';
 }
-
 function isKnexQueryBuilder(value) {
-  return (
-    hasConstructor(value) &&
-    isFunction(value.select) &&
-    isFunction(value.column) &&
-    value.select === value.column &&
-    'client' in 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;
+    return hasConstructor(value) && value.grouping === 'join' && 'joinType' in value;
 }
-
 function isKnexRaw(value) {
-  return hasConstructor(value) && value.isRawInstance && 'client' in value;
-}
-
-function isKnexTransaction(knex) {
-  return !!getDialect(knex) && isFunction(knex.commit) && isFunction(knex.rollback);
+    return hasConstructor(value) && value.isRawInstance && 'client' in value;
 }
-
 function hasConstructor(value) {
-  return isObject(value) && isFunction(value.constructor);
+    return (0, objectUtils_1.isObject)(value) && (0, objectUtils_1.isFunction)(value.constructor);
 }
-
-module.exports = {
-  getDialect,
-  isPostgres,
-  isMySql,
-  isSqlite,
-  isMsSql,
-  isOracle,
-  isKnexQueryBuilder,
-  isKnexJoinBuilder,
-  isKnexRaw,
-  isKnexTransaction,
-};

package/lib/utils/mixin.js

@@ -1,25 +1,18 @@
-'use strict';
-
-const { flatten } = require('./objectUtils');
-
-function mixin() {
-  const args = flatten(arguments);
-  const mixins = args.slice(1);
-
-  return mixins.reduce((Class, mixinFunc) => {
-    return mixinFunc(Class);
-  }, args[0]);
+"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() {
-  const mixins = flatten(arguments);
-
-  return function (Class) {
-    return mixin(Class, mixins);
-  };
+function compose(...composeArgs) {
+    const mixins = (0, objectUtils_1.flatten)(composeArgs);
+    return function (Class) {
+        return mixin(Class, mixins);
+    };
 }
-
-module.exports = {
-  compose,
-  mixin,
-};