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

package/lib/utils/createModifier.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const { asArray, isString, isFunction, isPlainObject } = require('./objectUtils');
+
+function createModifier({ modelClass, modifier, modifiers }) {
+  const modelModifiers = modelClass ? modelClass.getModifiers() : {};
+
+  const modifierFunctions = asArray(modifier).map((modifier) => {
+    let modify = null;
+
+    if (isString(modifier)) {
+      modify = (modifiers && modifiers[modifier]) || modelModifiers[modifier];
+
+      // Modifiers can be pointers to other modifiers. Call this function recursively.
+      if (modify && !isFunction(modify)) {
+        return createModifier({ modelClass, modifier: modify, modifiers });
+      }
+    } else if (isFunction(modifier)) {
+      modify = modifier;
+    } else if (isPlainObject(modifier)) {
+      modify = (builder) => builder.where(modifier);
+    } else if (Array.isArray(modifier)) {
+      return createModifier({ modelClass, modifier, modifiers });
+    }
+
+    if (!modify) {
+      modify = (builder) => modelClass.modifierNotFound(builder, modifier);
+    }
+
+    return modify;
+  });
+
+  return (builder, ...args) => {
+    for (const modifier of modifierFunctions) {
+      modifier.call(builder, builder, ...args);
+    }
+  };
+}
+
+module.exports = {
+  createModifier,
+};

package/lib/utils/deprecate.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const LOGGED_DEPRECATIONS = new Set();
+
+function deprecate(message) {
+  // Only log deprecation messages once.
+  if (!LOGGED_DEPRECATIONS.has(message)) {
+    LOGGED_DEPRECATIONS.add(message);
+    console.warn(message);
+  }
+}
+
+module.exports = {
+  deprecate,
+};

package/lib/utils/identifierMapping.js

@@ -0,0 +1,227 @@
+'use strict';
+
+const { isObject } = 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 (!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 = ':' } = {}) {
+  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,
+  });
+}
+
+module.exports = {
+  snakeCase,
+  camelCase,
+  snakeCaseMappers,
+  knexSnakeCaseMappers,
+  knexIdentifierMappers,
+  knexIdentifierMapping,
+
+  camelCaseKeys: keyMapper(memoize(camelCase)),
+  snakeCaseKeys: keyMapper(memoize(snakeCase)),
+};

package/lib/utils/internalPropUtils.js

@@ -0,0 +1,11 @@
+'use strict';
+
+const INTERNAL_PROP_PREFIX = '$';
+
+function isInternalProp(propName) {
+  return propName[0] === INTERNAL_PROP_PREFIX;
+}
+
+module.exports = {
+  isInternalProp,
+};

package/lib/utils/knexUtils.js

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

package/lib/utils/mixin.js

@@ -0,0 +1,25 @@
+'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]);
+}
+
+function compose() {
+  const mixins = flatten(arguments);
+
+  return function (Class) {
+    return mixin(Class, mixins);
+  };
+}
+
+module.exports = {
+  compose,
+  mixin,
+};

package/lib/utils/mysqlJsonPath.js

@@ -0,0 +1,55 @@
+'use strict';
+
+// 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';
+}
+
+module.exports = {
+  toMySqlJsonPath,
+  toMySqlCastType,
+  isBooleanType,
+};

package/lib/utils/normalizeIds.js

@@ -0,0 +1,144 @@
+'use strict';
+
+const { isObject } = require('../utils/objectUtils');
+
+// ids is of type RelationProperty.
+function normalizeIds(ids, prop, opt) {
+  opt = opt || {};
+
+  let 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 (isObject(ids[0])) {
+        ret = new Array(ids.length);
+
+        // 4.
+        for (let i = 0, l = ids.length; i < l; ++i) {
+          ret[i] = ensureObject(ids[i], prop);
+        }
+      } else {
+        // 1.
+        ret = [convertIdArrayToObject(ids, prop)];
+      }
+    } else if (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 (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 (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 (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;
+}
+
+module.exports = {
+  normalizeIds,
+};