objection 3.9.1 → 4.0.0-rc.2

package/lib/utils/mixin.js

@@ -1,8 +1,6 @@
-'use strict';
+import { flatten } from './objectUtils.js';
 
-const { flatten } = require('./objectUtils');
-
-function mixin() {
+export function mixin() {
   const args = flatten(arguments);
   const mixins = args.slice(1);
 
@@ -11,15 +9,10 @@ function mixin() {
   }, args[0]);
 }
 
-function compose() {
+export function compose() {
   const mixins = flatten(arguments);
 
   return function (Class) {
     return mixin(Class, mixins);
   };
 }
-
-module.exports = {
-  compose,
-  mixin,
-};

package/lib/utils/normalizeIds.js

@@ -1,9 +1,7 @@
-'use strict';
-
-const { isObject } = require('../utils/objectUtils');
+import { isObject } from '../utils/objectUtils.js';
 
 // ids is of type RelationProperty.
-function normalizeIds(ids, prop, opt) {
+export function normalizeIds(ids, prop, opt) {
   opt = opt || {};
 
   let isComposite = prop.size > 1;
@@ -138,7 +136,3 @@ function normalizedToArray(ret, prop) {
 
   return arr;
 }
-
-module.exports = {
-  normalizeIds,
-};

package/lib/utils/objectUtils.js

@@ -1,8 +1,6 @@
-'use strict';
-
 const SMALL_ARRAY_SIZE = 10;
 
-function isEmpty(item) {
+export function isEmpty(item) {
   if (Array.isArray(item) || Buffer.isBuffer(item)) {
     return item.length === 0;
   } else if (isObject(item)) {
@@ -12,17 +10,17 @@ function isEmpty(item) {
   }
 }
 
-function isObject(value) {
+export function isObject(value) {
   return value !== null && typeof value === 'object';
 }
 
-function hasOwn(obj, prop) {
+export function hasOwn(obj, prop) {
   return Object.prototype.hasOwnProperty.call(obj, prop);
 }
 
 // Quick and dirty check if an object is a plain object and not
 // for example an instance of some class.
-function isPlainObject(value) {
+export function isPlainObject(value) {
   return (
     isObject(value) &&
     (!value.constructor || value.constructor === Object) &&
@@ -30,31 +28,31 @@ function isPlainObject(value) {
   );
 }
 
-function isFunction(value) {
+export function isFunction(value) {
   return typeof value === 'function';
 }
 
-function isRegExp(value) {
+export function isRegExp(value) {
   return value instanceof RegExp;
 }
 
-function isString(value) {
+export function isString(value) {
   return typeof value === 'string';
 }
 
-function isNumber(value) {
+export function isNumber(value) {
   return typeof value === 'number';
 }
 
-function asArray(value) {
-  return Array.isArray(value) ? value : [value];
+export function asArray(value) {
+  return Array.isArray(value) ? value : value !== undefined ? [value] : [];
 }
 
-function asSingle(value) {
+export function asSingle(value) {
   return Array.isArray(value) ? value[0] : value;
 }
 
-function uniqBy(items, keyGetter = null) {
+export function uniqBy(items, keyGetter = null) {
   const map = new Map();
 
   for (let i = 0, l = items.length; i < l; ++i) {
@@ -67,7 +65,7 @@ function uniqBy(items, keyGetter = null) {
   return Array.from(map.values());
 }
 
-function groupBy(items, keyGetter = null) {
+export function groupBy(items, keyGetter = null) {
   const groups = new Map();
 
   for (const item of items) {
@@ -85,7 +83,7 @@ function groupBy(items, keyGetter = null) {
   return groups;
 }
 
-function omit(obj, keysToOmit) {
+export function omit(obj, keysToOmit) {
   keysToOmit = asArray(keysToOmit);
 
   const keys = Object.keys(obj);
@@ -102,7 +100,7 @@ function omit(obj, keysToOmit) {
   return out;
 }
 
-function difference(arr1, arr2) {
+export function difference(arr1, arr2) {
   const arr2Set = new Set(arr2);
   const diff = [];
 
@@ -117,7 +115,7 @@ function difference(arr1, arr2) {
   return diff;
 }
 
-function union(arr1, arr2) {
+export function union(arr1, arr2) {
   if (arr1.length < SMALL_ARRAY_SIZE && arr2.length < SMALL_ARRAY_SIZE) {
     return unionSmall(arr1, arr2);
   } else {
@@ -157,15 +155,15 @@ function unionGeneric(arr1, arr2) {
   return Array.from(all);
 }
 
-function last(arr) {
+export function last(arr) {
   return arr[arr.length - 1];
 }
 
-function upperFirst(str) {
+export function upperFirst(str) {
   return str[0].toUpperCase() + str.substring(1);
 }
 
-function values(obj) {
+export function values(obj) {
   if (isObject(obj)) {
     const keys = Object.keys(obj);
     const values = new Array(keys.length);
@@ -180,7 +178,7 @@ function values(obj) {
   }
 }
 
-function once(func) {
+export function once(func) {
   let called = false;
   let value = undefined;
 
@@ -194,7 +192,7 @@ function once(func) {
   };
 }
 
-function flatten(arrays) {
+export function flatten(arrays) {
   const out = [];
 
   for (let i = 0, l = arrays.length; i < l; ++i) {
@@ -212,7 +210,7 @@ function flatten(arrays) {
   return out;
 }
 
-function get(obj, path) {
+export function get(obj, path) {
   for (let i = 0, l = path.length; i < l; ++i) {
     const key = path[i];
 
@@ -226,7 +224,7 @@ function get(obj, path) {
   return obj;
 }
 
-function set(obj, path, value) {
+export function set(obj, path, value) {
   const inputObj = obj;
 
   for (let i = 0, l = path.length - 1; i < l; ++i) {
@@ -264,7 +262,7 @@ function set(obj, path, value) {
   return inputObj;
 }
 
-function zipObject(keys, values) {
+export function zipObject(keys, values) {
   const out = {};
 
   for (let i = 0, l = keys.length; i < l; ++i) {
@@ -278,7 +276,7 @@ function zipObject(keys, values) {
   return out;
 }
 
-function chunk(arr, chunkSize) {
+export function chunk(arr, chunkSize) {
   const out = [];
 
   for (let i = 0, l = arr.length; i < l; ++i) {
@@ -294,7 +292,20 @@ function chunk(arr, chunkSize) {
   return out;
 }
 
-function jsonEquals(val1, val2) {
+// Compare like the database would, but only use loose equality for non-JSON
+// values, so that for example `1` and `'1'` are equal, but `false` and `[]`
+// are not (#1874).
+export function nonStrictEquals(value1, value2) {
+  return (
+    (!isJsonValue(value1) && !isJsonValue(value2) && value1 == value2) || jsonEquals(value1, value2)
+  );
+}
+
+function isJsonValue(value) {
+  return Array.isArray(value) || isPlainObject(value);
+}
+
+export function jsonEquals(val1, val2) {
   return jsonEqualsBase(val1, val2, compareStrict);
 }
 
@@ -380,7 +391,7 @@ function isSafeKey(key) {
   return isNumber(key) || (isString(key) && key !== '__proto__');
 }
 
-function mergeMaps(map1, map2) {
+export function mergeMaps(map1, map2) {
   const map = new Map(map1);
 
   if (map2) {
@@ -429,7 +440,7 @@ function getRawTag(value) {
 // sets, buffers, typed arrays and array buffers are copied, circular
 // references are kept. Anything else, like functions, errors and built-ins
 // with internal state like `URL`, is kept as it is.
-function cloneDeep(value, clones = new Map()) {
+export function cloneDeep(value, clones = new Map()) {
   if (!isObject(value)) {
     return value;
   } else if (clones.has(value)) {
@@ -500,33 +511,3 @@ function cloneDeep(value, clones = new Map()) {
   clones.set(value, copy);
   return copy;
 }
-
-module.exports = {
-  isEmpty,
-  isString,
-  isRegExp,
-  isObject,
-  hasOwn,
-  isNumber,
-  isFunction,
-  jsonEquals,
-  isPlainObject,
-  difference,
-  upperFirst,
-  zipObject,
-  mergeMaps,
-  cloneDeep,
-  asSingle,
-  asArray,
-  flatten,
-  groupBy,
-  uniqBy,
-  values,
-  union,
-  chunk,
-  omit,
-  once,
-  last,
-  get,
-  set,
-};

package/lib/utils/parseFieldExpression.js

@@ -1,10 +1,8 @@
-'use strict';
-
-const jsonFieldExpressionParser = require('../queryBuilder/parsers/jsonFieldExpressionParser');
-const { isObject, hasOwn } = require('./objectUtils');
+import * as jsonFieldExpressionParser from '../queryBuilder/parsers/jsonFieldExpressionParser.js';
+import { isObject, hasOwn } from './objectUtils.js';
 const cache = new Map();
 
-function parseFieldExpression(expr) {
+export function parseFieldExpression(expr) {
   let parsedExpr = cache.get(expr);
 
   if (parsedExpr !== undefined) {
@@ -50,13 +48,13 @@ function freezeParsedExpr(parsedExpr) {
 // Keys with a ':' in the data of patches and updates are field expressions like
 // `'meta:a.b'` that write into json columns, unless they are `declared`: the
 // `properties` of the schema, or an object with their column names as keys.
-function isFieldExpressionKey(key, declared) {
+export function isFieldExpressionKey(key, declared) {
   return key.includes(':') && !(isObject(declared) && hasOwn(declared, key));
 }
 
 // Returns the json column of a field expression key like `'meta:a'`, or `null`
 // if the key isn't a field expression or doesn't parse as one.
-function getFieldExpressionColumn(key, declared) {
+export function getFieldExpressionColumn(key, declared) {
   if (isFieldExpressionKey(key, declared)) {
     try {
       return parseFieldExpression(key).column;
@@ -72,7 +70,7 @@ function getFieldExpressionColumn(key, declared) {
 // literal, e.g. `{a,"",b}`. Keys that would otherwise be misread (empty keys,
 // keys with whitespace, delimiters, quotes or backslashes and `NULL`) are
 // double-quoted, with quotes and backslashes escaped.
-function toPostgresJsonPath(access) {
+export function toPostgresJsonPath(access) {
   const keys = access.map(({ ref }) => {
     const key = String(ref);
     return key === '' || /[{}",\\\s]/.test(key) || key.toUpperCase() === 'NULL'
@@ -91,7 +89,7 @@ function toPostgresJsonPath(access) {
 // so they can't escape the closing quote either. But knex's Postgres dialect
 // drops all backslashes in front of an escaped `?`, so if the path contains any,
 // an escape string literal is used in which backslashes are written as `\134`.
-function toPostgresJsonPathLiteral(access) {
+export function toPostgresJsonPathLiteral(access) {
   const path = toPostgresJsonPath(access).replace(/'/g, "''");
 
   if (path.includes('\\?')) {
@@ -101,10 +99,12 @@ function toPostgresJsonPathLiteral(access) {
   }
 }
 
-module.exports = {
-  parseFieldExpression,
-  isFieldExpressionKey,
-  getFieldExpressionColumn,
-  toPostgresJsonPath,
-  toPostgresJsonPathLiteral,
-};
+// Formats the json path of a parsed field expression as a SQL/JSON path like
+// `$."a"[0]`, as MySQL and SQLite use it. Keys are always quoted, so that they
+// can't be misread.
+export function toJsonPath(access) {
+  const path = access.map(({ type, ref }) =>
+    type === 'array' ? `[${ref}]` : `.${JSON.stringify(String(ref))}`,
+  );
+  return `$${path.join('')}`;
+}

package/lib/utils/promiseUtils/after.js

@@ -1,17 +1,11 @@
-'use strict';
-
-const { isPromise } = require('./isPromise');
+import { isPromise } from './isPromise.js';
 
 // Call `func` after `obj` has been resolved. Call `func` synchronously if
 // `obj` is not a promise for performance reasons.
-function after(obj, func) {
+export function after(obj, func) {
   if (isPromise(obj)) {
     return obj.then(func);
   } else {
     return func(obj);
   }
 }
-
-module.exports = {
-  after,
-};

package/lib/utils/promiseUtils/afterReturn.js

@@ -1,17 +1,11 @@
-'use strict';
-
-const { isPromise } = require('./isPromise');
+import { isPromise } from './isPromise.js';
 
 // Return `returnValue` after `obj` has been resolved. Return `returnValue`
 // synchronously if `obj` is not a promise for performance reasons.
-function afterReturn(obj, returnValue) {
+export function afterReturn(obj, returnValue) {
   if (isPromise(obj)) {
     return obj.then(() => returnValue);
   } else {
     return returnValue;
   }
 }
-
-module.exports = {
-  afterReturn,
-};

package/lib/utils/promiseUtils/index.js

@@ -1,17 +1,8 @@
-'use strict';
+import { isPromise } from './isPromise.js';
+import { after } from './after.js';
+import { afterReturn } from './afterReturn.js';
+import { mapAfterAllReturn } from './mapAfterAllReturn.js';
+import { promiseMap } from './map.js';
+import { promiseTry } from './try.js';
 
-const { isPromise } = require('./isPromise');
-const { after } = require('./after');
-const { afterReturn } = require('./afterReturn');
-const { mapAfterAllReturn } = require('./mapAfterAllReturn');
-const { promiseMap } = require('./map');
-const { promiseTry } = require('./try');
-
-module.exports = {
-  isPromise,
-  after,
-  afterReturn,
-  mapAfterAllReturn,
-  map: promiseMap,
-  try: promiseTry,
-};
+export { isPromise, after, afterReturn, mapAfterAllReturn, promiseMap as map, promiseTry as try };

package/lib/utils/promiseUtils/isPromise.js

@@ -1,11 +1,5 @@
-'use strict';
+import { isObject, isFunction } from '../objectUtils.js';
 
-const { isObject, isFunction } = require('../objectUtils');
-
-function isPromise(obj) {
+export function isPromise(obj) {
   return isObject(obj) && isFunction(obj.then);
 }
-
-module.exports = {
-  isPromise,
-};

package/lib/utils/promiseUtils/map.js

@@ -1,9 +1,7 @@
-'use strict';
-
-const { isPromise } = require('./isPromise');
+import { isPromise } from './isPromise.js';
 
 // Works like Bluebird.map.
-function promiseMap(items, mapper, opt) {
+export function promiseMap(items, mapper, opt) {
   switch (items.length) {
     case 0:
       return mapZero();
@@ -121,7 +119,3 @@ function rejectWhenFinished(ctx) {
     ctx.reject(ctx.error);
   }
 }
-
-module.exports = {
-  promiseMap,
-};

package/lib/utils/promiseUtils/mapAfterAllReturn.js

@@ -1,11 +1,9 @@
-'use strict';
-
-const { isPromise } = require('./isPromise');
+import { isPromise } from './isPromise.js';
 
 // 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) {
+export function mapAfterAllReturn(arr, mapper, returnValue) {
   const results = new Array(arr.length);
   let containsPromise = false;
 
@@ -23,7 +21,3 @@ function mapAfterAllReturn(arr, mapper, returnValue) {
     return returnValue;
   }
 }
-
-module.exports = {
-  mapAfterAllReturn,
-};

package/lib/utils/promiseUtils/try.js

@@ -1,9 +1,7 @@
-'use strict';
-
-const { isPromise } = require('./isPromise');
+import { isPromise } from './isPromise.js';
 
 // Works like Bluebird.try.
-function promiseTry(callback) {
+export function promiseTry(callback) {
   try {
     const maybePromise = callback();
 
@@ -16,7 +14,3 @@ function promiseTry(callback) {
     return Promise.reject(err);
   }
 }
-
-module.exports = {
-  promiseTry,
-};

package/lib/utils/resolveModel.js

@@ -1,11 +1,14 @@
-'use strict';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { isString, isFunction } from '../utils/objectUtils.js';
 
-const path = require('path');
-const { isString, isFunction } = require('../utils/objectUtils');
+// Model files given as paths are loaded synchronously with `require()`, which
+// on Node >= 20.19 loads both CommonJS and ES modules (without top-level await).
+const require = createRequire(import.meta.url);
 
 class ResolveError extends Error {}
 
-function resolveModel(modelRef, modelPaths, errorPrefix) {
+export function resolveModel(modelRef, modelPaths, errorPrefix) {
   try {
     if (isString(modelRef)) {
       if (isAbsolutePath(modelRef)) {
@@ -20,7 +23,7 @@ function resolveModel(modelRef, modelPaths, errorPrefix) {
 
       if (!isModelClass(modelRef)) {
         throw new ResolveError(
-          `is not a subclass of Model or a file path to a module that exports one. You may be dealing with a require loop. See the documentation section about require loops.`,
+          `is not a subclass of Model or a file path to a module that exports one. You may be dealing with circular imports (a require loop). See the documentation section about circular imports.`,
         );
       }
 
@@ -56,19 +59,13 @@ function requireUsingModelPaths(modelRef, modelPaths) {
 }
 
 function requireModel(modelPath) {
-  /**
-   * Wrap path string in template literal to prevent
-   * warnings about Objection.JS being an expression
-   * in webpack builds.
-   * @link https://github.com/webpack/webpack/issues/196
-   */
-  let mod = require(`${path.resolve(modelPath)}`);
+  let mod = require(path.resolve(modelPath));
   let modelClass = null;
 
   if (isModelClass(mod)) {
     modelClass = mod;
   } else if (isModelClass(mod.default)) {
-    // Babel 6 style of exposing default export.
+    // ES module or Babel style default export.
     modelClass = mod.default;
   } else {
     Object.keys(mod).forEach((exportName) => {
@@ -100,7 +97,3 @@ function isAbsolutePath(pth) {
 function isModelClass(maybeModel) {
   return isFunction(maybeModel) && maybeModel.isObjectionModelClass;
 }
-
-module.exports = {
-  resolveModel,
-};

package/lib/utils/tmpColumnUtils.js

@@ -1,16 +1,9 @@
-'use strict';
-
 const OWNER_JOIN_COLUMN_ALIAS_PREFIX = 'objectiontmpjoin';
 
-function getTempColumn(index) {
+export function getTempColumn(index) {
   return `${OWNER_JOIN_COLUMN_ALIAS_PREFIX}${index}`;
 }
 
-function isTempColumn(col) {
+export function isTempColumn(col) {
   return col.startsWith(OWNER_JOIN_COLUMN_ALIAS_PREFIX);
 }
-
-module.exports = {
-  getTempColumn,
-  isTempColumn,
-};

package/lib/utils/warnings.js

@@ -1,26 +1,14 @@
-'use strict';
-
 const LOGGED_WARNINGS = new Set();
 
 // Log each warning only once.
-function warnOnce(message) {
+export function warnOnce(message) {
   if (!LOGGED_WARNINGS.has(message)) {
     LOGGED_WARNINGS.add(message);
     console.warn(`[objection] ${message}`);
   }
 }
 
-function deprecate(message) {
-  warnOnce(message);
-}
-
 // Only meant for tests that need to see a warning again.
-function resetWarnings() {
+export function resetWarnings() {
   LOGGED_WARNINGS.clear();
 }
-
-module.exports = {
-  warnOnce,
-  deprecate,
-  resetWarnings,
-};