@abedmurrar/objection 4.0.0-beta.2 → 4.0.0-beta.4

package/lib/queryBuilder/RelationExpression.js

@@ -1,15 +1,52 @@
-'use strict';
-const parser = require('./parsers/relationExpressionParser');
-const { isObject, isNumber, isString, union } = require('../utils/objectUtils');
-const { RelationDoesNotExistError } = require('../model/RelationDoesNotExistError');
+"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.DuplicateRelationError = exports.RelationExpressionParseError = exports.RelationExpression = void 0;
+const parser = __importStar(require("./parsers/relationExpressionParser"));
+const objectUtils_1 = require("../utils/objectUtils");
+const RelationDoesNotExistError_1 = require("../model/RelationDoesNotExistError");
 class RelationExpressionParseError extends Error {
 }
+exports.RelationExpressionParseError = RelationExpressionParseError;
 class DuplicateRelationError extends RelationExpressionParseError {
     constructor(relationName) {
         super();
         this.relationName = relationName;
     }
 }
+exports.DuplicateRelationError = DuplicateRelationError;
 class RelationExpression {
     constructor(node = newNode(), recursionDepth = 0) {
         this.node = node;
@@ -18,7 +55,7 @@ class RelationExpression {
     // Create a relation expression from a string, a pojo or another
     // RelationExpression instance.
     static create(expr) {
-        if (isObject(expr)) {
+        if ((0, objectUtils_1.isObject)(expr)) {
             if (expr.isObjectionRelationExpression) {
                 return expr;
             }
@@ -26,7 +63,7 @@ class RelationExpression {
                 return new RelationExpression(normalizeNode(expr));
             }
         }
-        else if (isString(expr)) {
+        else if ((0, objectUtils_1.isString)(expr)) {
             if (expr.trim().length === 0) {
                 return new RelationExpression();
             }
@@ -58,7 +95,7 @@ class RelationExpression {
         }
     }
     get maxRecursionDepth() {
-        if (isNumber(this.node.$recursive)) {
+        if ((0, objectUtils_1.isNumber)(this.node.$recursive)) {
             return this.node.$recursive;
         }
         else {
@@ -143,7 +180,7 @@ class RelationExpression {
                 const node = this.node[childName];
                 const relation = modelClass.getRelationUnsafe(node.$relation);
                 if (!relation) {
-                    throw new RelationDoesNotExistError(node.$relation);
+                    throw new RelationDoesNotExistError_1.RelationDoesNotExistError(node.$relation);
                 }
                 const childExpr = new RelationExpression(node);
                 cb(childExpr, relation);
@@ -156,6 +193,7 @@ class RelationExpression {
     clone() {
         return new RelationExpression(cloneNode(this.node), this.recursionDepth);
     }
+    // `null` for an empty expression.
     toString() {
         return toString(this.node);
     }
@@ -166,6 +204,7 @@ class RelationExpression {
         return this.toPojo();
     }
 }
+exports.RelationExpression = RelationExpression;
 const parseCache = new Map();
 function parse(str) {
     const cachedNode = parseCache.get(str);
@@ -194,10 +233,12 @@ function getChildNames(node) {
 }
 function toString(node) {
     const childNames = node.$childNames;
-    let childExpr = childNames.map((childName) => node[childName]).map(toString);
+    let childExpr = childNames
+        .map((childName) => node[childName])
+        .map(toString);
     let str = node.$relation;
     if (node.$recursive) {
-        if (isNumber(node.$recursive)) {
+        if ((0, objectUtils_1.isNumber)(node.$recursive)) {
             str += '.^' + node.$recursive;
         }
         else {
@@ -277,8 +318,10 @@ function normalizeNode(node = null, name = null, allRecusive = false) {
         $childNames: normalizeChildNames(node),
     };
     for (const childName of normalized.$childNames) {
+        // `node` isn't null here, since a null node has no child names.
         const childNode = node[childName];
-        if (isObject(childNode) || childNode === true) {
+        if ((0, objectUtils_1.isObject)(childNode) || childNode === true) {
+            // `true` is a node without any properties, like `{}`.
             normalized[childName] = normalizeNode(childNode, childName);
         }
     }
@@ -312,6 +355,7 @@ function findExpressionsAtPath(target, path, results) {
     }
     else {
         for (const childName of path.node.$childNames) {
+            // Not null, since `childName` is a child of `path`.
             const pathChild = path.childExpression(childName);
             const targetChild = target.childExpression(childName);
             if (targetChild) {
@@ -325,13 +369,13 @@ function mergeNodes(node1, node2) {
     const node = {
         $name: node1.$name,
         $relation: node1.$relation,
-        $modify: union(node1.$modify, node2.$modify),
+        $modify: (0, objectUtils_1.union)(node1.$modify, node2.$modify),
         $recursive: mergeRecursion(node1.$recursive, node2.$recursive),
         $allRecursive: node1.$allRecursive || node2.$allRecursive,
         $childNames: null,
     };
     if (!node.$recursive && !node.$allRecursive) {
-        node.$childNames = union(node1.$childNames, node2.$childNames);
+        node.$childNames = (0, objectUtils_1.union)(node1.$childNames, node2.$childNames);
         for (const childName of node.$childNames) {
             const child1 = node1[childName];
             const child2 = node2[childName];
@@ -346,13 +390,14 @@ function mergeNodes(node1, node2) {
     else {
         node.$childNames = [];
     }
+    // `$childNames` was set above.
     return node;
 }
 function mergeRecursion(rec1, rec2) {
     if (rec1 === true || rec2 === true) {
         return true;
     }
-    else if (isNumber(rec1) && isNumber(rec2)) {
+    else if ((0, objectUtils_1.isNumber)(rec1) && (0, objectUtils_1.isNumber)(rec2)) {
         return Math.max(rec1, rec2);
     }
     else {
@@ -366,8 +411,3 @@ Object.defineProperties(RelationExpression.prototype, {
         value: true,
     },
 });
-module.exports = {
-    RelationExpression,
-    RelationExpressionParseError,
-    DuplicateRelationError,
-};

package/lib/queryBuilder/ValueBuilder.js

@@ -1,15 +1,18 @@
-'use strict';
-const { asArray, isObject } = require('../utils/objectUtils');
-const { buildArg } = require('../utils/buildUtils');
-const { isMySql } = require('../utils/knexUtils');
-const { toMySqlCastType, isBooleanType, toJsonSql } = require('../utils/mysqlJsonPath');
-const { addExpressionMethods } = require('./expressions');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueBuilder = void 0;
+exports.val = val;
+const objectUtils_1 = require("../utils/objectUtils");
+const buildUtils_1 = require("../utils/buildUtils");
+const knexUtils_1 = require("../utils/knexUtils");
+const mysqlJsonPath_1 = require("../utils/mysqlJsonPath");
+const expressions_1 = require("./expressions");
 class ValueBuilder {
     constructor(value) {
         this._value = value;
         this._cast = null;
         // Cast objects and arrays to json by default.
-        this._toJson = isObject(value);
+        this._toJson = (0, objectUtils_1.isObject)(value);
         this._toArray = false;
         this._alias = null;
     }
@@ -67,29 +70,30 @@ class ValueBuilder {
             sql = '?';
         }
         else if (this._toArray) {
-            const values = asArray(this._value);
-            bindings.push(...values.map((it) => buildArg(it, builder)));
+            const values = (0, objectUtils_1.asArray)(this._value);
+            bindings.push(...values.map((it) => (0, buildUtils_1.buildArg)(it, builder)));
             sql = `ARRAY[${values.map(() => '?').join(', ')}]`;
         }
         else {
+            // A value of the user, which knex binds as it is.
             bindings.push(this._value);
             sql = '?';
         }
         const knex = builder.unsafeKnex();
-        const mysql = isMySql(knex);
+        const mysql = (0, knexUtils_1.isMySql)(knex);
         if (this._toJson && !this._cast && mysql) {
             // MySQL compares strings and JSON values as strings, so `{}` is never
             // equal to a JSON column without the cast. Postgres casts it implicitly.
-            sql = toJsonSql(sql, knex);
+            sql = (0, mysqlJsonPath_1.toJsonSql)(sql, knex);
         }
         else if (this._cast && mysql) {
-            const type = toMySqlCastType(this._cast);
+            const type = (0, mysqlJsonPath_1.toMySqlCastType)(this._cast);
             // MySQL can't cast to a boolean.
-            if (isBooleanType(this._cast)) {
+            if ((0, mysqlJsonPath_1.isBooleanType)(this._cast)) {
                 sql = `(${sql} <> 0)`;
             }
             else if (type === 'JSON') {
-                sql = toJsonSql(sql, knex);
+                sql = (0, mysqlJsonPath_1.toJsonSql)(sql, knex);
             }
             else {
                 sql = `CAST(${sql} AS ${type})`;
@@ -105,11 +109,8 @@ class ValueBuilder {
         return [sql, bindings];
     }
 }
-addExpressionMethods(ValueBuilder.prototype);
+exports.ValueBuilder = ValueBuilder;
+(0, expressions_1.addExpressionMethods)(ValueBuilder.prototype);
 function val(val) {
     return new ValueBuilder(val);
 }
-module.exports = {
-    ValueBuilder,
-    val,
-};

package/lib/queryBuilder/expressions.js

@@ -1,16 +1,8 @@
-'use strict';
-const { isObject } = require('../utils/objectUtils');
-// Comparison, logic and arithmetic methods for `ref()`, `val()`, `fn()` and
-// `raw()`, so that expressions can be written without raw sql:
-//
-//   Person.ref('age').gte(18).as('isAdult')
-//   Pet.ref('order').plus(1)
-//   Person.ref('firstName').isNotBlank().or(Person.ref('lastName').isNotBlank())
-//
-// Every method returns a new `FunctionBuilder`. The sql is wrapped in parentheses,
-// so expressions can be nested without thinking about operator precedence. The
-// arguments are bindings like the arguments of `fn()`: strings are values and
-// columns are passed with `ref()` or `Model.ref()`.
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addExpressionMethods = addExpressionMethods;
+exports.expression = expression;
+const objectUtils_1 = require("../utils/objectUtils");
 const COMPARISONS = {
     eq: '=',
     ne: '<>',
@@ -98,7 +90,9 @@ function createLogic(first, rest, operator) {
     return expression(`(${conditions.map(() => '?').join(` ${operator} `)})`, conditions);
 }
 function isSubquery(value) {
-    return (isObject(value) && (value.isObjectionQueryBuilderBase || typeof value.toSQL === 'function'));
+    return ((0, objectUtils_1.isObject)(value) &&
+        (value.isObjectionQueryBuilderBase ||
+            typeof value.toSQL === 'function'));
 }
 function expression(sql, args) {
     // Required here because `FunctionBuilder` itself gets these methods.
@@ -115,7 +109,3 @@ function addExpressionMethods(prototype) {
         });
     }
 }
-module.exports = {
-    addExpressionMethods,
-    expression,
-};

package/lib/queryBuilder/functions/mysql.js

@@ -1,35 +1,8 @@
-'use strict';
-const { ref } = require('../ReferenceBuilder');
-// The MySQL 8.4 built-in functions, as `fn.*` helpers.
-//
-// Each entry is `[name, sql, params, result, options]`:
-//
-//   name     the name of the helper: `fn.dateFormat()`
-//   sql      the name of the SQL function: `DATE_FORMAT`
-//   params   the parameters, as TypeScript
-//   result   the type of the result, as TypeScript
-//   options  `json`: the arguments that are JSON documents. Objects and arrays
-//                    passed to them are cast to JSON. An array of indexes,
-//                    'all', or 'even' (0, 2, 4, ...) / 'odd' (1, 3, 5, ...).
-//            `portable`: the function works the same on postgres, so it
-//                    isn't limited to MySQL.
-//            `build`: a function that builds the sql for functions with
-//                    keywords in their syntax, like `TIMESTAMPDIFF(DAY, ?, ?)`.
-//            `aggregate`: the function is an aggregate that `filter()` works
-//                    with. `true` when every argument is aggregated, or a
-//                    function that returns how many of the first arguments are.
-//            `window`: the function is a window function, which needs `over()`.
-//
-// The arguments are bindings, so strings are values. Columns are passed with
-// `ref()` or `Model.ref()`.
-//
-// The typings in `typings/objection/index.d.ts` are generated from this list
-// with `node scripts/generate-fn-typings.js`.
-//
-// Not included: spatial functions, operators, `CASE`, `JSON_TABLE()`, internal functions and functions
-// that are deprecated (`JSON_MERGE()`, `FOUND_ROWS()`, `VALUES()`,
-// `MASTER_POS_WAIT()`) or that need a component (`VALIDATE_PASSWORD_STRENGTH()`).
-// `fn('NAME', ...args)` calls any function.
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TIMESTAMP_UNITS = exports.INTERVAL_UNITS = exports.MARIADB_UNSUPPORTED = exports.FUNCTIONS = void 0;
+exports.buildOrderBy = buildOrderBy;
+const ReferenceBuilder_1 = require("../ReferenceBuilder");
 const STR = 'string | null';
 const NUM = 'number | null';
 const DEC = 'FnNumeric | null';
@@ -66,7 +39,9 @@ const INTERVAL_UNITS = [
     'DAY_HOUR',
     'YEAR_MONTH',
 ];
+exports.INTERVAL_UNITS = INTERVAL_UNITS;
 const TIMESTAMP_UNITS = INTERVAL_UNITS.slice(0, 9);
+exports.TIMESTAMP_UNITS = TIMESTAMP_UNITS;
 const CAST_TYPE = /^((BINARY|CHAR|NCHAR)(\(\d+\))?( CHARACTER SET \w+)?|DATE|(DATETIME|TIME)(\(\d\))?|DECIMAL(\(\d+(, ?\d+)?\))?|DOUBLE|FLOAT(\(\d+\))?|JSON|REAL|(SIGNED|UNSIGNED)( INTEGER)?|YEAR)$/i;
 const CHARSET = /^\w+$/;
 const MATCH_MODES = {
@@ -540,6 +515,7 @@ const FUNCTIONS = [
         { json: [0, 1], build: buildMemberOf },
     ],
 ];
+exports.FUNCTIONS = FUNCTIONS;
 // Builders for the functions with keywords in their syntax. They return
 // `[sql, args]`. Keywords are checked against lists, since they can't be bindings.
 function buildDateAdd(name, sql, [date, amount, unit]) {
@@ -592,6 +568,7 @@ function buildTrim(name, sql, [str, options = {}]) {
     }
 }
 function buildChar(name, sql, [codes, options = {}]) {
+    // `codes`, `columns` and `exprs` below are arrays after the first line.
     codes = Array.isArray(codes) ? codes : [codes];
     const placeholders = codes.map(() => '?').join(', ');
     if (options.using === undefined) {
@@ -612,7 +589,10 @@ function buildMatch(name, sql, [columns, search, options = {}]) {
         }
         mode = ` ${mode}`;
     }
-    return [`MATCH(${columns.map(() => '?').join(', ')}) AGAINST(?${mode})`, [...columns, search]];
+    return [
+        `MATCH(${columns.map(() => '?').join(', ')}) AGAINST(?${mode})`,
+        [...columns, search],
+    ];
 }
 function buildCountDistinct(name, sql, exprs) {
     return [`COUNT(DISTINCT ${exprs.map(() => '?').join(', ')})`, exprs];
@@ -653,7 +633,7 @@ function buildOrderBy(name, orderBy) {
     return [sql, args];
 }
 function toColumn(column) {
-    return typeof column === 'string' ? ref(column) : column;
+    return typeof column === 'string' ? (0, ReferenceBuilder_1.ref)(column) : column;
 }
 function buildNtile(name, sql, [buckets]) {
     return [`NTILE(${integer(name, 'buckets', buckets, 1)})`, []];
@@ -751,12 +731,8 @@ const MARIADB_UNSUPPORTED = {
     regexpInstr: MAX_ARGS(2),
     regexpSubstr: MAX_ARGS(2),
     regexpReplace: MAX_ARGS(3),
-    jsonValue: (args) => args[2] && args[2].returning !== undefined ? "can't use the returning option on MariaDB" : null,
-};
-module.exports = {
-    FUNCTIONS,
-    MARIADB_UNSUPPORTED,
-    buildOrderBy,
-    INTERVAL_UNITS,
-    TIMESTAMP_UNITS,
+    jsonValue: (args) => args[2] && args[2].returning !== undefined
+        ? "can't use the returning option on MariaDB"
+        : null,
 };
+exports.MARIADB_UNSUPPORTED = MARIADB_UNSUPPORTED;

package/lib/queryBuilder/join/JoinResultColumn.js

@@ -1,11 +1,15 @@
-'use strict';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JoinResultColumn = void 0;
 class JoinResultColumn {
+    // The arguments are the properties of the column.
     constructor({ columnAlias, tableNode, name }) {
         this.columnAlias = columnAlias;
         this.tableNode = tableNode;
         this.name = name;
     }
     static create({ tableTree, columnAlias }) {
+        // The column aliases of the joined query are those of the table tree.
         const tableNode = tableTree.getNodeForColumnAlias(columnAlias);
         return new JoinResultColumn({
             columnAlias,
@@ -14,6 +18,4 @@ class JoinResultColumn {
         });
     }
 }
-module.exports = {
-    JoinResultColumn,
-};
+exports.JoinResultColumn = JoinResultColumn;

package/lib/queryBuilder/join/JoinResultParser.js

@@ -1,6 +1,8 @@
-'use strict';
-const { JoinResultColumn } = require('./JoinResultColumn');
-const { groupBy } = require('../../utils/objectUtils');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JoinResultParser = void 0;
+const JoinResultColumn_1 = require("./JoinResultColumn");
+const objectUtils_1 = require("../../utils/objectUtils");
 class JoinResultParser {
     constructor({ tableTree, omitColumnAliases = [] }) {
         this.tableTree = tableTree;
@@ -54,6 +56,8 @@ class JoinResultParser {
             }
         }
         const model = tableNode.modelClass.fromDatabaseJson(row);
+        // The child nodes and the node of a parent model always have a relation
+        // and a relation property.
         for (const childNode of tableNode.childNodes) {
             if (childNode.relation.isOneToOne()) {
                 model[childNode.relationProperty] = null;
@@ -80,12 +84,13 @@ class JoinResultParser {
     }
     _createColumns(row) {
         const columns = Object.keys(row)
-            .map((columnAlias) => JoinResultColumn.create({ tableTree: this.tableTree, columnAlias }))
+            .map((columnAlias) => JoinResultColumn_1.JoinResultColumn.create({ tableTree: this.tableTree, columnAlias }))
             // The omitted columns are filtered here once instead of for every model.
             .filter((column) => !this.omitColumnAliases.has(column.columnAlias));
-        return groupBy(columns, getTableNode);
+        return (0, objectUtils_1.groupBy)(columns, getTableNode);
     }
 }
+exports.JoinResultParser = JoinResultParser;
 function getTableNode(column) {
     return column.tableNode;
 }
@@ -101,6 +106,3 @@ function createChildMaps(tableNode) {
     }
     return maps;
 }
-module.exports = {
-    JoinResultParser,
-};

package/lib/queryBuilder/join/RelationJoiner.js

@@ -1,13 +1,15 @@
-'use strict';
-const { uniqBy } = require('../../utils/objectUtils');
-const { Selection } = require('../operations/select/Selection');
-const { createModifier } = require('../../utils/createModifier');
-const { map: mapPromise } = require('../../utils/promiseUtils');
-const { getReadConcurrency } = require('../../model/modelConcurrency');
-const { ValidationErrorType } = require('../../model/ValidationError');
-const { TableTree } = require('./TableTree');
-const { JoinResultParser } = require('./JoinResultParser');
-const { ID_LENGTH_LIMIT } = require('./utils');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationJoiner = void 0;
+const objectUtils_1 = require("../../utils/objectUtils");
+const Selection_1 = require("../operations/select/Selection");
+const createModifier_1 = require("../../utils/createModifier");
+const promiseUtils_1 = require("../../utils/promiseUtils");
+const modelConcurrency_1 = require("../../model/modelConcurrency");
+const ValidationError_1 = require("../../model/ValidationError");
+const TableTree_1 = require("./TableTree");
+const JoinResultParser_1 = require("./JoinResultParser");
+const utils_1 = require("./utils");
 /**
  * Given a relation expression, builds a query using joins to fetch it.
  */
@@ -47,8 +49,8 @@ class RelationJoiner {
     fetchColumnInfo(builder) {
         const tableTree = this._getTableTree(builder);
         const allModelClasses = new Set(tableTree.nodes.map((node) => node.modelClass));
-        return mapPromise(Array.from(allModelClasses), (modelClass) => modelClass.fetchTableMetadata({ parentBuilder: builder }), {
-            concurrency: getReadConcurrency(this.rootModelClass, builder.unsafeKnex()),
+        return (0, promiseUtils_1.map)(Array.from(allModelClasses), (modelClass) => modelClass.fetchTableMetadata({ parentBuilder: builder }), {
+            concurrency: (0, modelConcurrency_1.getReadConcurrency)(this.rootModelClass, builder.unsafeKnex()),
         });
     }
     build(builder, buildSelects = true) {
@@ -62,7 +64,7 @@ class RelationJoiner {
         }
     }
     parseResult(builder, flatRows) {
-        const parser = JoinResultParser.create({
+        const parser = JoinResultParser_1.JoinResultParser.create({
             tableTree: this._getTableTree(builder),
             omitColumnAliases: this.internalSelections.map((it) => it.alias),
         });
@@ -71,7 +73,7 @@ class RelationJoiner {
     _getTableTree(builder) {
         if (!this.tableTree) {
             // Create the table tree lazily.
-            this.tableTree = TableTree.create({
+            this.tableTree = TableTree_1.TableTree.create({
                 rootModelClass: this.rootModelClass,
                 rootTableAlias: builder.tableRef(),
                 expression: this.expression,
@@ -80,7 +82,7 @@ class RelationJoiner {
         }
         return this.tableTree;
     }
-    _buildJoinsForNode({ builder, tableNode, userSelectQueries }) {
+    _buildJoinsForNode({ builder, tableNode, userSelectQueries, }) {
         const subqueryToJoin = createSubqueryToJoin({
             builder,
             tableNode,
@@ -107,13 +109,14 @@ class RelationJoiner {
             this._buildJoinsForNode({ builder, tableNode: childNode, userSelectQueries });
         }
     }
-    _buildSelects({ builder, tableNode, userSelectQueries }) {
+    _buildSelects({ builder, tableNode, userSelectQueries, }) {
         const { selections, internalSelections } = getSelectionsForNode({
             builder,
             tableNode,
             userSelectQueries,
         });
         for (const selection of selections) {
+            // The selections that are added here all have an alias.
             checkAliasLength(tableNode.modelClass, selection.name);
         }
         // Save the selections that were added internally (not by the user)
@@ -123,6 +126,7 @@ class RelationJoiner {
         builder.select(selectionsToStrings(selections));
     }
 }
+exports.RelationJoiner = RelationJoiner;
 function defaultOptions() {
     return {
         joinOperation: 'leftJoin',
@@ -131,11 +135,11 @@ function defaultOptions() {
         aliases: {},
     };
 }
-function createSubqueryToJoin({ builder, tableNode, modifiers }) {
+function createSubqueryToJoin({ builder, tableNode, modifiers, }) {
     const { relation, expression, modelClass } = tableNode;
     const modifierQuery = modelClass.query().childQueryOf(builder);
     for (const modifierName of expression.node.$modify) {
-        const modifier = createModifier({
+        const modifier = (0, createModifier_1.createModifier)({
             modifier: modifierName,
             modelClass,
             modifiers,
@@ -146,7 +150,7 @@ function createSubqueryToJoin({ builder, tableNode, modifiers }) {
         catch (err) {
             if (err instanceof modelClass.ModifierNotFoundError) {
                 throw modelClass.createValidationError({
-                    type: ValidationErrorType.RelationExpression,
+                    type: ValidationError_1.ValidationErrorType.RelationExpression,
                     message: `could not find modifier "${modifierName}" for relation "${relation.name}"`,
                 });
             }
@@ -157,19 +161,20 @@ function createSubqueryToJoin({ builder, tableNode, modifiers }) {
     }
     return modifierQuery;
 }
-function ensureIdAndRelationPropsAreSelected({ builder, tableNode }) {
+function ensureIdAndRelationPropsAreSelected({ builder, tableNode, }) {
     const tableRef = builder.tableRef();
     const cols = [
         ...builder.modelClass().getIdColumnArray(),
         ...tableNode.relation.relatedProp.cols,
         ...tableNode.childNodes.reduce((cols, childNode) => [...cols, ...childNode.relation.ownerProp.cols], []),
     ];
-    const selectStrings = uniqBy(cols)
+    const selectStrings = (0, objectUtils_1.uniqBy)(cols)
         .filter((col) => !builder.hasSelectionAs(col, col))
         .map((col) => `${tableRef}.${col}`);
     return builder.select(selectStrings);
 }
-function getSelectionsForNode({ builder, tableNode, userSelectQueries }) {
+function getSelectionsForNode({ builder, tableNode, userSelectQueries, }) {
+    // Every node has a query: `build()` and `_buildJoinsForNode()` add them.
     const userSelectQuery = userSelectQueries.get(tableNode);
     const userSelections = userSelectQuery.findAllSelections();
     const userSelectedAllColumns = isSelectAllSelectionSet(userSelections);
@@ -189,6 +194,7 @@ function getSelectionsForNode({ builder, tableNode, userSelectQueries }) {
     else {
         const idSelections = getIdSelectionsForNode({ tableNode });
         for (const idSelection of idSelections) {
+            // The id selections have a column.
             if (!userSelectQuery.hasSelectionAs(idSelection.column, idSelection.column)) {
                 selections.push(idSelection);
                 internalSelections.push(idSelection);
@@ -205,29 +211,31 @@ function getSelectionsForNode({ builder, tableNode, userSelectQueries }) {
         internalSelections,
     };
 }
-function mapUserSelectionsFromSubqueryToMainQuery({ userSelections, tableNode }) {
+function mapUserSelectionsFromSubqueryToMainQuery({ userSelections, tableNode, }) {
     return userSelections.filter(isNotSelectAll).map((selection) => {
-        return new Selection(tableNode.alias, selection.name, tableNode.getColumnAliasForColumn(selection.name));
+        // A user selection that isn't `*` has a name.
+        return new Selection_1.Selection(tableNode.alias, selection.name, tableNode.getColumnAliasForColumn(selection.name));
     });
 }
-function getJoinTableExtraSelectionsForNode({ builder, tableNode }) {
+function getJoinTableExtraSelectionsForNode({ builder, tableNode, }) {
     return tableNode.relation.joinTableExtras.map((extra) => {
-        return new Selection(tableNode.getJoinTableAlias(builder), extra.joinTableCol, tableNode.getColumnAliasForColumn(extra.aliasCol));
+        // A many to many relation, which has a join table.
+        return new Selection_1.Selection(tableNode.getJoinTableAlias(builder), extra.joinTableCol, tableNode.getColumnAliasForColumn(extra.aliasCol));
     });
 }
-function getAllColumnSelectionsForNode({ builder, tableNode }) {
+function getAllColumnSelectionsForNode({ builder, tableNode, }) {
     const table = builder.tableNameFor(tableNode.modelClass);
     const tableMeta = tableNode.modelClass.tableMetadata({ table });
     if (!tableMeta) {
         throw new Error(`table metadata has not been fetched for table '${table}'. Are you trying to call toKnexQuery() for a withGraphJoined query? To make sure the table metadata is fetched see the objection.initialize function.`);
     }
     return tableMeta.columns.map((columnName) => {
-        return new Selection(tableNode.alias, columnName, tableNode.getColumnAliasForColumn(columnName));
+        return new Selection_1.Selection(tableNode.alias, columnName, tableNode.getColumnAliasForColumn(columnName));
     });
 }
 function getIdSelectionsForNode({ tableNode }) {
     return tableNode.modelClass.getIdColumnArray().map((columnName) => {
-        return new Selection(tableNode.alias, columnName, tableNode.getColumnAliasForColumn(columnName));
+        return new Selection_1.Selection(tableNode.alias, columnName, tableNode.getColumnAliasForColumn(columnName));
     });
 }
 function selectionsToStrings(selections) {
@@ -246,13 +254,10 @@ function isSelectAllSelectionSet(selections) {
     return selections.length === 0 || selections.some(isSelectAll);
 }
 function checkAliasLength(modelClass, alias) {
-    if (alias.length > ID_LENGTH_LIMIT) {
+    if (alias.length > utils_1.ID_LENGTH_LIMIT) {
         throw modelClass.createValidationError({
-            type: ValidationErrorType.RelationExpression,
-            message: `identifier ${alias} is over ${ID_LENGTH_LIMIT} characters long and would be truncated by the database engine.`,
+            type: ValidationError_1.ValidationErrorType.RelationExpression,
+            message: `identifier ${alias} is over ${utils_1.ID_LENGTH_LIMIT} characters long and would be truncated by the database engine.`,
         });
     }
 }
-module.exports = {
-    RelationJoiner,
-};