@rvoh/dream 0.29.1

package/dist/esm/src/dream/Query.js

@@ -0,0 +1,2615 @@
+import { sql, } from 'kysely';
+import { DateTime } from 'luxon';
+import pluralize from 'pluralize-esm';
+import ConnectedToDB from '../db/ConnectedToDB.js';
+import associationToGetterSetterProp from '../decorators/associations/associationToGetterSetterProp.js';
+import { SOFT_DELETE_SCOPE_NAME } from '../decorators/SoftDelete.js';
+import CannotAssociateThroughPolymorphic from '../errors/associations/CannotAssociateThroughPolymorphic.js';
+import CannotJoinPolymorphicBelongsToError from '../errors/associations/CannotJoinPolymorphicBelongsToError.js';
+import JoinAttemptedOnMissingAssociation from '../errors/associations/JoinAttemptedOnMissingAssociation.js';
+import MissingRequiredAssociationOnClause from '../errors/associations/MissingRequiredAssociationOnClause.js';
+import MissingRequiredPassthroughForAssociationOnClause from '../errors/associations/MissingRequiredPassthroughForAssociationOnClause.js';
+import MissingThroughAssociation from '../errors/associations/MissingThroughAssociation.js';
+import MissingThroughAssociationSource from '../errors/associations/MissingThroughAssociationSource.js';
+import CannotCallUndestroyOnANonSoftDeleteModel from '../errors/CannotCallUndestroyOnANonSoftDeleteModel.js';
+import CannotNegateSimilarityClause from '../errors/CannotNegateSimilarityClause.js';
+import CannotPassAdditionalFieldsToPluckEachAfterCallback from '../errors/CannotPassAdditionalFieldsToPluckEachAfterCallback.js';
+import CannotPassUndefinedAsAValueToAWhereClause from '../errors/CannotPassUndefinedAsAValueToAWhereClause.js';
+import LeftJoinPreloadIncompatibleWithFindEach from '../errors/LeftJoinPreloadIncompatibleWithFindEach.js';
+import MissingRequiredCallbackFunctionToPluckEach from '../errors/MissingRequiredCallbackFunctionToPluckEach.js';
+import NoUpdateAllOnJoins from '../errors/NoUpdateAllOnJoins.js';
+import NoUpdateOnAssociationQuery from '../errors/NoUpdateOnAssociationQuery.js';
+import RecordNotFound from '../errors/RecordNotFound.js';
+import CalendarDate from '../helpers/CalendarDate.js';
+import camelize from '../helpers/camelize.js';
+import cloneDeepSafe from '../helpers/cloneDeepSafe.js';
+import compact from '../helpers/compact.js';
+import isEmpty from '../helpers/isEmpty.js';
+import namespaceColumn from '../helpers/namespaceColumn.js';
+import objectPathsToArrays from '../helpers/objectPathsToArrays.js';
+import protectAgainstPollutingAssignment from '../helpers/protectAgainstPollutingAssignment.js';
+import { Range } from '../helpers/range.js';
+import snakeify from '../helpers/snakeify.js';
+import { isObject, isString } from '../helpers/typechecks.js';
+import uniq from '../helpers/uniq.js';
+import CurriedOpsStatement from '../ops/curried-ops-statement.js';
+import ops from '../ops/index.js';
+import OpsStatement from '../ops/ops-statement.js';
+import executeDatabaseQuery from './internal/executeDatabaseQuery.js';
+import extractAssociationMetadataFromAssociationName from './internal/extractAssociationMetadataFromAssociationName.js';
+import orderByDirection from './internal/orderByDirection.js';
+import shouldBypassDefaultScope from './internal/shouldBypassDefaultScope.js';
+import SimilarityBuilder from './internal/similarity/SimilarityBuilder.js';
+import sqlResultToDreamInstance from './internal/sqlResultToDreamInstance.js';
+import { DreamConst, } from './types.js';
+export default class Query extends ConnectedToDB {
+    /**
+     * @internal
+     *
+     * stores the default batch sizes for various
+     * provided batching methods
+     */
+    static BATCH_SIZES = {
+        FIND_EACH: 1000,
+        PLUCK_EACH: 10000,
+        PLUCK_EACH_THROUGH: 1000,
+    };
+    /**
+     * @internal
+     * purely for typing
+     */
+    queryTypeOpts;
+    /**
+     * @internal
+     *
+     * stores the dream transaction applied to the
+     * current Query instance
+     */
+    dreamTransaction = null;
+    /**
+     * @internal
+     *
+     * stores the passthrough on statements applied to the
+     * current Query instance
+     */
+    passthroughOnStatement = Object.freeze({});
+    /**
+     * @internal
+     *
+     * stores the where statements applied to the
+     * current Query instance
+     */
+    whereStatements = Object.freeze([]);
+    /**
+     * @internal
+     *
+     * stores the where not statements applied to the
+     * current Query instance
+     */
+    whereNotStatements = Object.freeze([]);
+    /**
+     * @internal
+     *
+     * stores the limit statements applied to the
+     * current Query instance
+     */
+    limitStatement;
+    /**
+     * @internal
+     *
+     * stores the offset statements applied to the
+     * current Query instance
+     */
+    offsetStatement;
+    /**
+     * @internal
+     *
+     * stores the or statements applied to the
+     * current Query instance
+     */
+    whereAnyStatements = Object.freeze([]);
+    /**
+     * @internal
+     *
+     * stores the order statements applied to the
+     * current Query instance
+     */
+    orderStatements = Object.freeze([]);
+    /**
+     * @internal
+     *
+     * whether or not to turn joins into load statements
+     */
+    joinLoadActivated = false;
+    /**
+     * @internal
+     *
+     * stores the preload statements applied to the
+     * current Query instance
+     */
+    preloadStatements = Object.freeze({});
+    /**
+     * @internal
+     *
+     * stores the preload on statements applied to the
+     * current Query instance
+     */
+    preloadOnStatements = Object.freeze({});
+    /**
+     * @internal
+     *
+     * stores the joins statements applied to the
+     * current Query instance
+     */
+    innerJoinStatements = Object.freeze({});
+    /**
+     * @internal
+     *
+     * stores the joins on statements applied to the
+     * current Query instance
+     */
+    innerJoinOnStatements = Object.freeze({});
+    /**
+     * @internal
+     *
+     * stores the joins statements applied to the
+     * current Query instance
+     */
+    leftJoinStatements = Object.freeze({});
+    /**
+     * @internal
+     *
+     * stores the joins on statements applied to the
+     * current Query instance
+     */
+    leftJoinOnStatements = Object.freeze({});
+    /**
+     * @internal
+     *
+     * Whether or not to bypass all default scopes for this Query
+     */
+    bypassAllDefaultScopes = false;
+    /**
+     * @internal
+     *
+     * Whether or not to bypass all default scopes for this Query, but not associations
+     */
+    bypassAllDefaultScopesExceptOnAssociations = false;
+    /**
+     * @internal
+     *
+     * Specific default scopes to bypass
+     */
+    defaultScopesToBypass = [];
+    /**
+     * @internal
+     *
+     * Specific default scopes to bypass, but not associations
+     */
+    defaultScopesToBypassExceptOnAssociations = [];
+    /**
+     * @internal
+     *
+     * Whether or not to bypass SoftDelete and really destroy a record
+     * when calling destroy.
+     */
+    shouldReallyDestroy = false;
+    /**
+     * @internal
+     *
+     * The distinct column to apply to the Query
+     */
+    distinctColumn = null;
+    /**
+     * @internal
+     *
+     * The base sql alias to use for the base model
+     * of this Query
+     */
+    baseSqlAlias;
+    get tableName() {
+        return this.dreamClass.table;
+    }
+    get namespacedPrimaryKey() {
+        return namespaceColumn(this.dreamClass.primaryKey, this.baseSqlAlias);
+    }
+    /**
+     * @internal
+     *
+     * Used for unscoping Query instances. In most cases, this will be null,
+     * but when calling `removeAllDefaultScopes`, a removeAllDefaultScopes Query is stored as
+     * baseSelectQuery.
+     */
+    baseSelectQuery;
+    constructor(dreamInstance, opts = {}) {
+        super(dreamInstance, opts);
+        this.passthroughOnStatement = Object.freeze(opts.passthroughOnStatement || {});
+        this.whereStatements = Object.freeze(opts.where || []);
+        this.whereNotStatements = Object.freeze(opts.whereNot || []);
+        this.whereAnyStatements = Object.freeze(opts.or || []);
+        this.orderStatements = Object.freeze(opts.order || []);
+        this.joinLoadActivated = opts.loadFromJoins || false;
+        this.preloadStatements = Object.freeze(opts.preloadStatements || {});
+        this.preloadOnStatements = Object.freeze(opts.preloadOnStatements || {});
+        this.innerJoinStatements = Object.freeze(opts.innerJoinStatements || {});
+        this.innerJoinOnStatements = Object.freeze(opts.innerJoinOnStatements || {});
+        this.leftJoinStatements = Object.freeze(opts.leftJoinStatements || {});
+        this.leftJoinOnStatements = Object.freeze(opts.leftJoinOnStatements || {});
+        this.baseSqlAlias = opts.baseSqlAlias || this.tableName;
+        this.baseSelectQuery = opts.baseSelectQuery || null;
+        this.limitStatement = opts.limit || null;
+        this.offsetStatement = opts.offset || null;
+        this.bypassAllDefaultScopes = opts.bypassAllDefaultScopes || false;
+        this.bypassAllDefaultScopesExceptOnAssociations = opts.bypassAllDefaultScopesExceptOnAssociations || false;
+        this.defaultScopesToBypass = opts.defaultScopesToBypass || [];
+        this.defaultScopesToBypassExceptOnAssociations = opts.defaultScopesToBypassExceptOnAssociations || [];
+        this.dreamTransaction = opts.transaction || null;
+        this.distinctColumn = opts.distinctColumn || null;
+        this.connectionOverride = opts.connection;
+        this.shouldReallyDestroy = opts.shouldReallyDestroy || false;
+    }
+    /**
+     * Returns true. Useful for distinguishing Query instances
+     * from other objects.
+     *
+     * @returns true
+     */
+    get isDreamQuery() {
+        return true;
+    }
+    /**
+     * @internal
+     *
+     * Used for applying preload and load statements
+     *
+     * @returns An associated Query
+     */
+    dreamClassQueryWithScopeBypasses(dreamClass, { bypassAllDefaultScopesExceptOnAssociations = false, defaultScopesToBypassExceptOnAssociations = [], } = {}) {
+        const associationQuery = dreamClass.query().clone({
+            passthroughOnStatement: this.passthroughOnStatement,
+            bypassAllDefaultScopes: this.bypassAllDefaultScopes,
+            bypassAllDefaultScopesExceptOnAssociations,
+            defaultScopesToBypass: this.defaultScopesToBypass,
+            defaultScopesToBypassExceptOnAssociations,
+        });
+        return (this.dreamTransaction ? associationQuery.txn(this.dreamTransaction) : associationQuery);
+    }
+    /**
+     * @internal
+     *
+     * Returns a cloned version of the Query
+     *
+     * ```ts
+     * const clonedQuery = User.query().clone()
+     * ```
+     *
+     * @param opts - Statements to override when cloning the Query
+     * @returns A cloned Query with the provided overrides clause applied
+     */
+    clone(opts = {}) {
+        return new Query(this.dreamInstance, {
+            baseSqlAlias: opts.baseSqlAlias || this.baseSqlAlias,
+            baseSelectQuery: opts.baseSelectQuery || this.baseSelectQuery,
+            passthroughOnStatement: {
+                ...this.passthroughOnStatement,
+                ...(opts.passthroughOnStatement || {}),
+            },
+            where: opts.where === null ? [] : [...this.whereStatements, ...(opts.where || [])],
+            whereNot: opts.whereNot === null ? [] : [...this.whereNotStatements, ...(opts.whereNot || [])],
+            limit: opts.limit === null ? null : opts.limit !== undefined ? opts.limit : this.limitStatement || null,
+            offset: opts.limit === null || opts.offset === null
+                ? null
+                : opts.offset !== undefined
+                    ? opts.offset
+                    : this.offsetStatement || null,
+            or: opts.or === null ? [] : [...this.whereAnyStatements, ...(opts.or || [])],
+            order: opts.order === null ? [] : [...this.orderStatements, ...(opts.order || [])],
+            distinctColumn: opts.distinctColumn !== undefined ? opts.distinctColumn : this.distinctColumn,
+            loadFromJoins: opts.loadFromJoins !== undefined ? opts.loadFromJoins : this.joinLoadActivated,
+            // when passed, preloadStatements, preloadOnStatements, innerJoinStatements, and innerJoinOnStatements are already
+            // cloned versions of the `this.` versions, handled in the `preload` and `joins` methods
+            preloadStatements: opts.preloadStatements || this.preloadStatements,
+            preloadOnStatements: opts.preloadOnStatements || this.preloadOnStatements,
+            innerJoinDreamClasses: opts.innerJoinDreamClasses || this.innerJoinDreamClasses,
+            innerJoinStatements: opts.innerJoinStatements || this.innerJoinStatements,
+            innerJoinOnStatements: opts.innerJoinOnStatements || this.innerJoinOnStatements,
+            leftJoinStatements: opts.leftJoinStatements || this.leftJoinStatements,
+            leftJoinOnStatements: opts.leftJoinOnStatements || this.leftJoinOnStatements,
+            // end:when passed, preloadStatements, preloadOnStatements, innerJoinStatements, and innerJoinOnStatements are already...
+            bypassAllDefaultScopes: opts.bypassAllDefaultScopes !== undefined ? opts.bypassAllDefaultScopes : this.bypassAllDefaultScopes,
+            bypassAllDefaultScopesExceptOnAssociations: opts.bypassAllDefaultScopesExceptOnAssociations !== undefined
+                ? opts.bypassAllDefaultScopesExceptOnAssociations
+                : this.bypassAllDefaultScopesExceptOnAssociations,
+            defaultScopesToBypass: opts.defaultScopesToBypass !== undefined ? opts.defaultScopesToBypass : this.defaultScopesToBypass,
+            defaultScopesToBypassExceptOnAssociations: opts.defaultScopesToBypassExceptOnAssociations !== undefined
+                ? opts.defaultScopesToBypassExceptOnAssociations
+                : this.defaultScopesToBypassExceptOnAssociations,
+            transaction: opts.transaction || this.dreamTransaction,
+            connection: opts.connection || this.connectionOverride,
+            shouldReallyDestroy: opts.shouldReallyDestroy !== undefined ? opts.shouldReallyDestroy : this.shouldReallyDestroy,
+        });
+    }
+    /**
+     * Finds a record matching the Query with the
+     * specified primary key. If not found, null
+     * is returned.
+     *
+     * ```ts
+     * await User.query().find(123)
+     * // User{id: 123}
+     * ```
+     *
+     * @param primaryKey - The primary key of the record to look up
+     * @returns Either the found record, or else null
+     */
+    async find(primaryKey) {
+        if (!primaryKey)
+            return null;
+        return await this.where({
+            [this.dreamInstance.primaryKey]: primaryKey,
+        }).first();
+    }
+    /**
+     * Finds a record matching the Query with the
+     * specified primary key. If not found, an exception
+     * is raised.
+     *
+     * ```ts
+     * await User.query().findOrFail(123)
+     * // User{id: 123}
+     * ```
+     *
+     * @param primaryKey - The primary key of the record to look up
+     * @returns The found record
+     */
+    async findOrFail(primaryKey) {
+        const record = await this.find(primaryKey);
+        if (!record)
+            throw new RecordNotFound(this.dreamInstance.constructor.name);
+        return record;
+    }
+    /**
+     * Finds a record matching the Query and the
+     * specified where statement. If not found, null
+     * is returned.
+     *
+     * ```ts
+     * await User.query().findBy({ email: 'how@yadoin' })
+     * // User{email: 'how@yadoin'}
+     * ```
+     *
+     * @param whereStatement - The where statement used to locate the record
+     * @returns Either the first record found matching the attributes, or else null
+     */
+    async findBy(whereStatement) {
+        return await this._where(whereStatement, 'where').first();
+    }
+    /**
+     * Finds a record matching the Query and the
+     * specified where statement. If not found, an exception
+     * is raised.
+     *
+     * ```ts
+     * await User.query().findOrFailBy({ email: 'how@yadoin' })
+     * // User{email: 'how@yadoin'}
+     * ```
+     *
+     * @param whereStatement - The where statement used to locate the record
+     * @returns The first record found matching the attributes
+     */
+    async findOrFailBy(whereStatement) {
+        const record = await this.findBy(whereStatement);
+        if (!record)
+            throw new RecordNotFound(this.dreamInstance.constructor.name);
+        return record;
+    }
+    /**
+     * Finds all records matching the Query in batches,
+     * and then calls the provided callback for each found record.
+     * Once all records have been passed for a given batch, the next set of
+     * records will be fetched and passed to your callback, until all
+     * records matching the Query have been fetched.
+     *
+     * ```ts
+     * await User.order('id').findEach(user => {
+     *   DreamApplication.log(user)
+     * })
+     * // User{id: 1}
+     * // User{id: 2}
+     * ```
+     *
+     * @param cb - The callback to call for each found record
+     * @param options - Options for destroying the instance
+     * @param options.batchSize - The batch size you wish to collect records in. If not provided, it will default to 1000
+     * @returns void
+     */
+    async findEach(cb, { batchSize = Query.BATCH_SIZES.FIND_EACH } = {}) {
+        if (this.joinLoadActivated)
+            throw new LeftJoinPreloadIncompatibleWithFindEach();
+        let records;
+        const query = this.order(null)
+            .order(this.namespacedPrimaryKey)
+            .limit(batchSize);
+        let lastId = null;
+        do {
+            if (lastId)
+                records = await query.where({ [this.dreamInstance.primaryKey]: ops.greaterThan(lastId) }).all();
+            else
+                records = await query.all();
+            for (const record of records) {
+                await cb(record);
+            }
+            lastId = records[records.length - 1]?.primaryKeyValue;
+        } while (records.length > 0 && records.length === batchSize);
+    }
+    /**
+     * Load each specified association using a single SQL query.
+     * See {@link #preload} for preloading in separate queries.
+     *
+     * Note: since leftJoinPreload loads via single query, it has
+     * some downsides and that may be avoided using {@link #preload}:
+     * 1. `limit` and `offset` will be automatically removed
+     * 2. `through` associations will bring additional namespaces into the query that can conflict with through associations from other associations, creating an invalid query
+     * 3. each nested association will result in an additional record which duplicates data from the outer record. E.g., given `.leftJoinPreload('a', 'b', 'c')`, if each `a` has 10 `b` and each `b` has 10 `c`, then for one `a`, 100 records will be returned, each of which has all of the columns of `a`. `.preload('a', 'b', 'c')` would perform three separate SQL queries, but the data for a single `a` would only be returned once.
+     * 4. the individual query becomes more complex the more associations are included
+     * 5. associations loading associations loading associations could result in exponential amounts of data; in those cases, `.preload(...).findEach(...)` avoids instantiating massive amounts of data at once
+     *
+     *
+     * ```ts
+     * const posts = await user.associationQuery('posts').leftJoinPreload('comments', { visibilty: 'public' }, 'replies').all()
+     * console.log(posts[0].comments[0].replies[0])
+     * // [Reply{id: 1}, Reply{id: 2}]
+     * ```
+     *
+     * @param args - A chain of association names and on/notOn/onAny clauses
+     * @returns A cloned Query with the joinLoad statement applied
+     */
+    leftJoinPreload(...args) {
+        const untypedArgs = [...args];
+        const lastAssociations = [untypedArgs.pop()].flat();
+        let joinedClone = this;
+        lastAssociations.forEach(associationName => {
+            joinedClone = joinedClone.leftJoin(...untypedArgs, associationName);
+        });
+        return joinedClone.clone({ loadFromJoins: true });
+    }
+    /**
+     * Load each specified association using a separate SQL query.
+     * See {@link #leftJoinPreload} for preloading in a single query.
+     *
+     * ```ts
+     * const user = await User.query().preload('posts', 'comments', { visibilty: 'public' }, 'replies').first()
+     * console.log(user.posts[0].comments[0].replies[0])
+     * // [Reply{id: 1}, Reply{id: 2}]
+     * ```
+     *
+     * @param args - A chain of association names and on/notOn/onAny clauses
+     * @returns A cloned Query with the preload statement applied
+     */
+    preload(...args) {
+        const preloadStatements = cloneDeepSafe(this.preloadStatements);
+        const preloadOnStatements = cloneDeepSafe(this.preloadOnStatements);
+        this.fleshOutJoinStatements([], preloadStatements, preloadOnStatements, null, [...args]);
+        return this.clone({ preloadStatements, preloadOnStatements: preloadOnStatements });
+    }
+    /**
+     * Returns a new Query instance, with the provided
+     * joins statement attached
+     *
+     * ```ts
+     * await User.query().innerJoin('posts').first()
+     * ```
+     *
+     * @param args - A chain of association names and on/notOn/onAny clauses
+     * @returns A cloned Query with the joins clause applied
+     */
+    innerJoin(...args) {
+        const innerJoinDreamClasses = [...this.innerJoinDreamClasses];
+        const innerJoinStatements = cloneDeepSafe(this.innerJoinStatements);
+        const innerJoinOnStatements = cloneDeepSafe(this.innerJoinOnStatements);
+        this.fleshOutJoinStatements(innerJoinDreamClasses, innerJoinStatements, innerJoinOnStatements, null, [...args]);
+        return this.clone({ innerJoinDreamClasses, innerJoinStatements, innerJoinOnStatements });
+    }
+    /**
+     * @internal
+     *
+     * @param args - A chain of association names and on/notOn/onAny clauses
+     * @returns A cloned Query with the joins clause applied
+     */
+    leftJoin(...args) {
+        const innerJoinDreamClasses = [...this.innerJoinDreamClasses];
+        const leftJoinStatements = cloneDeepSafe(this.leftJoinStatements);
+        const leftJoinOnStatements = cloneDeepSafe(this.leftJoinOnStatements);
+        this.fleshOutJoinStatements(innerJoinDreamClasses, leftJoinStatements, leftJoinOnStatements, null, [
+            ...args,
+        ]);
+        return this.clone({ innerJoinDreamClasses, leftJoinStatements, leftJoinOnStatements });
+    }
+    /**
+     * @internal
+     *
+     */
+    fleshOutJoinStatements(innerJoinDreamClasses, joinStatements, joinOnStatements, previousAssociationName, associationStatements, previousDreamClass = this.dreamClass) {
+        const nextAssociationStatement = associationStatements.shift();
+        if (nextAssociationStatement === undefined) {
+            // just satisfying typing
+        }
+        else if (isString(nextAssociationStatement)) {
+            const nextStatement = nextAssociationStatement;
+            if (!joinStatements[nextStatement])
+                joinStatements[protectAgainstPollutingAssignment(nextStatement)] = {};
+            if (!joinOnStatements[nextStatement])
+                joinOnStatements[protectAgainstPollutingAssignment(nextStatement)] = {};
+            const nextDreamClass = this.addAssociatedDreamClassToInnerJoinDreamClasses(previousDreamClass, nextStatement, innerJoinDreamClasses);
+            const nextJoinsStatements = joinStatements[nextStatement];
+            const nextJoinsOnStatements = joinOnStatements[nextStatement];
+            this.fleshOutJoinStatements(innerJoinDreamClasses, nextJoinsStatements, nextJoinsOnStatements, nextStatement, associationStatements, nextDreamClass);
+            //
+        }
+        else if (Array.isArray(nextAssociationStatement)) {
+            // this supports the final argument of load/preload statements
+            nextAssociationStatement.forEach((associationName) => {
+                this.addAssociatedDreamClassToInnerJoinDreamClasses(previousDreamClass, associationName, innerJoinDreamClasses);
+            });
+            nextAssociationStatement.forEach(associationStatement => {
+                joinStatements[protectAgainstPollutingAssignment(associationStatement)] = {};
+            });
+            //
+        }
+        else if (isObject(nextAssociationStatement) && previousAssociationName) {
+            const clonedNextAssociationStatement = cloneDeepSafe(nextAssociationStatement);
+            const keys = Object.keys(clonedNextAssociationStatement);
+            keys.forEach((key) => {
+                joinOnStatements[protectAgainstPollutingAssignment(key)] = clonedNextAssociationStatement[key];
+            });
+            this.fleshOutJoinStatements(innerJoinDreamClasses, joinStatements, joinOnStatements, previousAssociationName, associationStatements, previousDreamClass);
+        }
+    }
+    /**
+     * @internal
+     *
+     *
+     */
+    associationNamesToDreamClassesMap(associationNames, associationsToDreamClassesMap = {}) {
+        const namesToAssociationsAndDreamClasses = this.associationNamesToAssociationDataAndDreamClassesMap(associationNames);
+        return Object.keys(namesToAssociationsAndDreamClasses).reduce((remap, associationName) => {
+            remap[associationName] = namesToAssociationsAndDreamClasses[associationName].dreamClass;
+            return remap;
+        }, associationsToDreamClassesMap);
+    }
+    /**
+     * @internal
+     *
+     *
+     */
+    associationNamesToAssociationsMap(associationNames, associationsToAssociations = {}) {
+        const namesToAssociationsAndDreamClasses = this.associationNamesToAssociationDataAndDreamClassesMap(associationNames);
+        return Object.keys(namesToAssociationsAndDreamClasses).reduce((remap, associationName) => {
+            remap[associationName] = namesToAssociationsAndDreamClasses[associationName].association;
+            return remap;
+        }, associationsToAssociations);
+    }
+    /**
+     * @internal
+     */
+    associationNamesToAssociationDataAndDreamClassesMap(associationNames) {
+        const associationsToDreamClassesMap = {};
+        associationNames.reduce((dreamClass, associationName) => {
+            const { name, alias } = extractAssociationMetadataFromAssociationName(associationName);
+            const association = dreamClass['getAssociationMetadata'](name);
+            const through = association.through;
+            if (through) {
+                const { throughAssociation, throughAssociationDreamClass } = this.throughAssociationDetails(dreamClass, through);
+                associationsToDreamClassesMap[through] = {
+                    association: throughAssociation,
+                    dreamClass: throughAssociationDreamClass,
+                };
+            }
+            const nextDreamClass = association.modelCB();
+            associationsToDreamClassesMap[alias] = { association, dreamClass: nextDreamClass };
+            return nextDreamClass;
+        }, this.dreamClass);
+        return associationsToDreamClassesMap;
+    }
+    /**
+     * @internal
+     */
+    throughAssociationDetails(dreamClass, through) {
+        const throughAssociation = dreamClass['getAssociationMetadata'](through);
+        const throughAssociationDreamClass = throughAssociation.modelCB();
+        return { throughAssociation, throughAssociationDreamClass };
+    }
+    /**
+     * @internal
+     *
+     *
+     */
+    joinStatementsToDreamClassesMap(joinStatements) {
+        const associationsToDreamClassesMap = {};
+        objectPathsToArrays(joinStatements).forEach(associationChain => this.associationNamesToDreamClassesMap(associationChain, associationsToDreamClassesMap));
+        return associationsToDreamClassesMap;
+    }
+    /**
+     * @internal
+     *
+     *
+     */
+    joinStatementsToAssociationsMap(joinStatements) {
+        const associationsToAssociationsMap = {};
+        objectPathsToArrays(joinStatements).forEach(associationChain => this.associationNamesToAssociationsMap(associationChain, associationsToAssociationsMap));
+        return associationsToAssociationsMap;
+    }
+    /**
+     * @internal
+     *
+     * Adds Dream class to temporary innerJoinDreamClasses array based on association name
+     *
+     */
+    addAssociatedDreamClassToInnerJoinDreamClasses(previousDreamClass, associationName, innerJoinDreamClasses) {
+        if (!previousDreamClass)
+            return null;
+        const association = previousDreamClass['associationMetadataMap']()[associationName];
+        if (!association)
+            return null;
+        this.addThroughAssociatedDreamClassToInnerJoinDreamClasses(previousDreamClass, association, innerJoinDreamClasses);
+        const dreamClasses = [association.modelCB()].flat();
+        dreamClasses.forEach(dreamClass => innerJoinDreamClasses.push(dreamClass));
+        return dreamClasses[0];
+    }
+    addThroughAssociatedDreamClassToInnerJoinDreamClasses(dreamClass, _association, innerJoinDreamClasses) {
+        const association = _association;
+        const throughAssociationName = association.through;
+        if (!throughAssociationName)
+            return;
+        const throughAssociation = dreamClass['associationMetadataMap']()[throughAssociationName];
+        if (!throughAssociation)
+            return;
+        const throughDreamClass = [throughAssociation.modelCB()].flat()[0];
+        innerJoinDreamClasses.push(throughDreamClass);
+        this.addThroughAssociatedDreamClassToInnerJoinDreamClasses(dreamClass, throughAssociation, innerJoinDreamClasses);
+    }
+    /**
+     * @internal
+     *
+     * Changes the base sql alias
+     *
+     */
+    setBaseSQLAlias(baseSqlAlias) {
+        return this.clone({ baseSqlAlias });
+    }
+    /**
+     * @internal
+     *
+     * Association queries start from the table corresponding to an instance
+     * of a Dream and join the association. However, the Dream may have
+     * default scopes that would preclude finding that instance, so the
+     * Query that forms the base of an association query must be unscoped,
+     * but that unscoping should not carry through to other associations
+     * (thus the use of `removeAllDefaultScopesExceptOnAssociations` instead of
+     * `removeAllDefaultScopes`).
+     *
+     * The association that this query is loading leverages `joins`, and the
+     * joining code explicitly handles applying / omitting default scopes.
+     * We set `bypassAllDefaultScopesExceptOnAssociations: true` on this Query
+     * to let that code do its work. This keeps the implementation DRY and simpler
+     * (without `bypassAllDefaultScopesExceptOnAssociations`, the default scopes would
+     * be applied twice, and when the association attempts to remove a default
+     * association would be foiled because it would be applied outside of the context
+     * where the association is modifying the query).
+     *
+     */
+    setAssociationQueryBase(baseSelectQuery) {
+        return this.clone({
+            baseSelectQuery: baseSelectQuery.removeAllDefaultScopesExceptOnAssociations(),
+            bypassAllDefaultScopesExceptOnAssociations: true,
+        });
+    }
+    /**
+     * Prevents default scopes from applying when
+     * the Query is executed
+     *
+     * @returns A new Query which will prevent default scopes from applying
+     */
+    removeAllDefaultScopes() {
+        return this.clone({
+            bypassAllDefaultScopes: true,
+            baseSelectQuery: this.baseSelectQuery?.removeAllDefaultScopes(),
+        });
+    }
+    /**
+     * Prevents default scopes from applying when
+     * the Query is executed, but not when applying to associations
+     *
+     * @returns A new Query which will prevent default scopes from applying, but not when applying to asociations
+     */
+    removeAllDefaultScopesExceptOnAssociations() {
+        return this.clone({
+            bypassAllDefaultScopesExceptOnAssociations: true,
+            baseSelectQuery: this.baseSelectQuery?.removeAllDefaultScopesExceptOnAssociations(),
+        });
+    }
+    /**
+     * Prevents a specific default scope from applying when
+     * the Query is executed
+     *
+     * @returns A new Query which will prevent a specific default scope from applying
+     */
+    removeDefaultScope(scopeName) {
+        return this.clone({
+            defaultScopesToBypass: [...this.defaultScopesToBypass, scopeName],
+            baseSelectQuery: this.baseSelectQuery?.removeDefaultScope(scopeName),
+        });
+    }
+    /**
+     * Prevents a specific default scope from applying when
+     * the Query is executed, but not when applying to asociations
+     *
+     * @returns A new Query which will prevent a specific default scope from applying, but not when applying to asociations
+     */
+    removeDefaultScopeExceptOnAssociations(scopeName) {
+        return this.clone({
+            defaultScopesToBypassExceptOnAssociations: [
+                ...this.defaultScopesToBypassExceptOnAssociations,
+                scopeName,
+            ],
+            baseSelectQuery: this.baseSelectQuery?.removeDefaultScopeExceptOnAssociations(scopeName),
+        });
+    }
+    /**
+     * Sends data through for use as passthrough data
+     * for the associations that require it.
+     *
+     * ```ts
+     * class Post {
+     *   @Deco.HasMany('LocalizedText')
+     *   public localizedTexts: LocalizedText[]
+     *
+     *   @Deco.HasOne('LocalizedText', {
+     *     on: { locale: DreamConst.passthrough },
+     *   })
+     *   public currentLocalizedText: LocalizedText
+     * }
+     *
+     * await User.query().passthrough({ locale: 'es-ES' })
+     *   .preload('posts', 'currentLocalizedText')
+     *   .first()
+     * ```
+     *
+     * @param passthroughOnStatement - where statement used for associations that require passthrough data
+     * @returns A cloned Query with the passthrough data
+     */
+    passthrough(passthroughOnStatement) {
+        return this.clone({ passthroughOnStatement: passthroughOnStatement });
+    }
+    /**
+     * Applies a where statement to the Query instance
+     *
+     * ```ts
+     * await User.where({ email: 'how@yadoin' }).first()
+     * // User{email: 'how@yadoin'}
+     * ```
+     *
+     * @param whereStatement - Where statement to apply to the Query
+     * @returns A cloned Query with the where clause applied
+     */
+    where(whereStatement) {
+        return this._where(whereStatement, 'where');
+    }
+    /**
+     * Accepts a list of where statements, each of
+     * which is combined via `OR`
+     *
+     * ```ts
+     * await User.query().whereAny([{ email: 'how@yadoin' }, { name: 'fred' }]).first()
+     * // [User{email: 'how@yadoin'}, User{name: 'fred'}, User{name: 'fred'}]
+     * ```
+     *
+     * @param whereStatements - a list of where statements to `OR` together
+     * @returns A cloned Query with the whereAny clause applied
+     */
+    whereAny(whereStatements) {
+        return this.clone({
+            or: whereStatements ? [whereStatements.map((obj) => ({ ...obj }))] : whereStatements,
+        });
+    }
+    /**
+     * Applies a whereNot statement to the Query instance
+     *
+     * ```ts
+     * await User.query().whereNot({ email: 'how@yadoin' }).first()
+     * // User{email: 'hello@world'}
+     * ```
+     *
+     * @param whereStatement - A where statement to negate and apply to the Query
+     * @returns A cloned Query with the whereNot clause applied
+     */
+    whereNot(whereStatement) {
+        return this._where(whereStatement, 'whereNot');
+    }
+    /**
+     * @internal
+     *
+     * Applies a where clause
+     */
+    _where(whereStatement, typeOfWhere) {
+        return this.clone({
+            [typeOfWhere]: whereStatement === null ? null : [{ ...whereStatement }],
+        });
+    }
+    /**
+     * Returns a new Kysely SelectQueryBuilder instance to be used
+     * in a sub Query
+     *
+     * ```ts
+     * const records = await User.where({
+     *   id: Post.query().nestedSelect('userId'),
+     * }).all()
+     * // [User{id: 1}, ...]
+     * ```
+     *
+     * @param selection - the column to use for your nested Query
+     * @returns A Kysely SelectQueryBuilder instance
+     */
+    nestedSelect(selection) {
+        const query = this.buildSelect({ bypassSelectAll: true, bypassOrder: true });
+        return query.select(this.namespaceColumn(selection));
+    }
+    /**
+     * Returns a new Query instance, attaching the provided
+     * order statement
+     *
+     * ```ts
+     * await User.query().order('id').all()
+     * // [User{id: 1}, User{id: 2}, ...]
+     * ```
+     *
+     * ```ts
+     * await User.query().order({ name: 'asc', id: 'desc' }).all()
+     * // [User{name: 'a', id: 99}, User{name: 'a', id: 97}, User{ name: 'b', id: 98 } ...]
+     * ```
+     *
+     * @param orderStatement - Either a string or an object specifying order. If a string, the order is implicitly ascending. If the orderStatement is an object, statements will be provided in the order of the keys set in the object
+     * @returns A cloned Query with the order clause applied
+     */
+    order(arg) {
+        if (arg === null)
+            return this.clone({ order: null });
+        if (isString(arg))
+            return this.clone({ order: [{ column: arg, direction: 'asc' }] });
+        let query = this.clone();
+        Object.keys(arg).forEach(key => {
+            const column = key;
+            const direction = arg[key];
+            query = query.clone({
+                order: [{ column: column, direction }],
+            });
+        });
+        return query;
+    }
+    /**
+     * Returns a new Query instance, specifying a limit
+     *
+     * ```ts
+     * await User.order('id').limit(2).all()
+     * // [User{id: 1}, User{id: 2}]
+     * ```
+     *
+     * @returns A cloned Query with the limit clause applied
+     */
+    limit(limit) {
+        return this.clone({ limit });
+    }
+    /**
+     * Returns a new Query instance, specifying an offset
+     *
+     * ```ts
+     * await User.order('id').offset(2).limit(2).all()
+     * // [User{id: 3}, User{id: 4}]
+     * ```
+     *
+     * @returns A cloned Query with the offset clause applied
+     */
+    offset(offset) {
+        return this.clone({ offset });
+    }
+    /**
+     * Returns the sql that would be executed by this Query
+     *
+     * ```ts
+     * User.where({ email: 'how@yadoin' }).sql()
+     * // {
+     * //  query: {
+     * //    kind: 'SelectQueryNode',
+     * //    from: { kind: 'FromNode', froms: [Array] },
+     * //    selections: [ [Object] ],
+     * //    distinctOn: undefined,
+     * //    joins: undefined,
+     * //    groupBy: undefined,
+     * //    orderBy: undefined,
+     * //    where: { kind: 'WhereNode', where: [Object] },
+     * //    frontModifiers: undefined,
+     * //    endModifiers: undefined,
+     * //    limit: undefined,
+     * //    offset: undefined,
+     * //    with: undefined,
+     * //    having: undefined,
+     * //    explain: undefined,
+     * //    setOperations: undefined
+     * //  },
+     * //  sql: 'select "users".* from "users" where ("users"."email" = $1 and "users"."deleted_at" is null)',
+     * //  parameters: [ 'how@yadoin' ]
+     * //}
+     * ```
+     *
+     * @returns An object representing the underlying sql statement
+     *
+     */
+    sql() {
+        const kyselyQuery = this.buildSelect();
+        return kyselyQuery.compile();
+    }
+    /**
+     * Converts the given dream class into a Kysely query, enabling
+     * you to build custom queries using the Kysely API
+     *
+     * ```ts
+     * await User.query().toKysely('select').where('email', '=', 'how@yadoin').execute()
+     * ```
+     *
+     * @param type - the type of Kysely query builder instance you would like to obtain
+     * @returns A Kysely query. Depending on the type passed, it will return either a SelectQueryBuilder, DeleteQueryBuilder, or an UpdateQueryBuilder
+     */
+    toKysely(type) {
+        switch (type) {
+            case 'select':
+                return this.buildSelect();
+            case 'delete':
+                return this.buildDelete();
+            case 'update':
+                return this.buildUpdate({});
+            // TODO: in the future, we should support insert type, but don't yet, since inserts are done outside
+            // the query class for some reason.
+            default:
+                throw new Error('never');
+        }
+    }
+    /**
+     * Applies transaction to the Query instance
+     *
+     * ```ts
+     * await ApplicationModel.transaction(async txn => {
+     *   await User.query().txn(txn).create({ email: 'how@yadoin' })
+     * })
+     * ```
+     *
+     * @param txn - A DreamTransaction instance (usually collected by calling `ApplicationModel.transaction`)
+     * @returns A cloned Query with the transaction applied
+     *
+     */
+    txn(dreamTransaction) {
+        return this.clone({ transaction: dreamTransaction });
+    }
+    /**
+     * Retrieves the number of records in the database
+     *
+     * ```ts
+     * await User.query().count()
+     * ```
+     *
+     * @returns The number of records in the database
+     */
+    async count() {
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        const { count } = this.dbFor('select').fn;
+        const distinctColumn = this.distinctColumn;
+        const query = this.clone({ distinctColumn: null });
+        let kyselyQuery = query.buildSelect({ bypassSelectAll: true, bypassOrder: true });
+        const countClause = distinctColumn
+            ? count(sql `DISTINCT ${distinctColumn}`)
+            : count(query.namespaceColumn(query.dreamInstance.primaryKey));
+        kyselyQuery = kyselyQuery.select(countClause.as('tablecount'));
+        const data = await executeDatabaseQuery(kyselyQuery, 'executeTakeFirstOrThrow');
+        return parseInt(data.tablecount.toString());
+    }
+    /**
+     * Returns new Query with distinct clause applied
+     *
+     * ```ts
+     * await User.query().distinct('name').pluck('name')
+     * ```
+     *
+     * @returns A cloned Query with the distinct clause applied
+     */
+    distinct(column = true) {
+        if (column === true) {
+            return this.clone({
+                distinctColumn: this.namespaceColumn(this.dreamInstance.primaryKey),
+            });
+        }
+        else if (column === false) {
+            return this.clone({ distinctColumn: null });
+        }
+        else {
+            return this.clone({ distinctColumn: this.namespaceColumn(column) });
+        }
+    }
+    /**
+     * @internal
+     *
+     * Returns a namespaced column name
+     *
+     * @returns A string
+     */
+    namespaceColumn(column, alias = this.baseSqlAlias) {
+        return namespaceColumn(column, alias);
+    }
+    /**
+     * Retrieves the max value of the specified column
+     * for this Query
+     *
+     * ```ts
+     * await User.query().max('id')
+     * // 99
+     * ```
+     *
+     * @param columnName - a column name on the model
+     * @returns the max value of the specified column for this Query
+     *
+     */
+    async max(columnName) {
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        const { max } = this.dbFor('select').fn;
+        let kyselyQuery = this.buildSelect({ bypassSelectAll: true, bypassOrder: true });
+        kyselyQuery = kyselyQuery.select(max(columnName));
+        const data = await executeDatabaseQuery(kyselyQuery, 'executeTakeFirstOrThrow');
+        return data.max;
+    }
+    /**
+     * Retrieves the min value of the specified column
+     * for this Query
+     *
+     * ```ts
+     * await User.query().min('id')
+     * // 1
+     * ```
+     *
+     * @param columnName - a column name on the model
+     * @returns the min value of the specified column for this Query
+     */
+    async min(columnName) {
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        const { min } = this.dbFor('select').fn;
+        let kyselyQuery = this.buildSelect({ bypassSelectAll: true, bypassOrder: true });
+        kyselyQuery = kyselyQuery.select(min(columnName));
+        const data = await executeDatabaseQuery(kyselyQuery, 'executeTakeFirstOrThrow');
+        return data.min;
+    }
+    /**
+     * @internal
+     *
+     * Runs the query and extracts plucked values
+     *
+     * @returns An array of plucked values
+     */
+    async executePluck(...fields) {
+        let kyselyQuery = this.removeAllDefaultScopesExceptOnAssociations().buildSelect({ bypassSelectAll: true });
+        const aliases = [];
+        fields.forEach((field) => {
+            // field will already be namespaced in a join situation, but when the field to pluck is on the
+            // base model, it will be underscored (to match the table name), but when the selected column
+            // comes back from Kysely camelCased
+            aliases.push(field.includes('_') ? camelize(field) : field);
+            kyselyQuery = kyselyQuery.select(`${this.namespaceColumn(field)} as ${field}`);
+        });
+        return (await executeDatabaseQuery(kyselyQuery, 'execute')).map(singleResult => aliases.map(alias => singleResult[alias]));
+    }
+    /**
+     * @internal
+     *
+     */
+    async executeJoinLoad(options = {}) {
+        const query = this.limit(null).offset(null);
+        let kyselyQuery = query.buildSelect({ bypassSelectAll: true });
+        const aliasToDreamClassesMap = {
+            [this.baseSqlAlias]: this.dreamClass,
+            ...this.joinStatementsToDreamClassesMap(this.leftJoinStatements),
+        };
+        const associationAliasToColumnAliasMap = {};
+        const aliasToAssociationsMap = this.joinStatementsToAssociationsMap(this.leftJoinStatements);
+        const aliases = Object.keys(aliasToDreamClassesMap);
+        let nextColumnAliasCounter = 0;
+        aliases.forEach((aliasOrExpression) => {
+            const alias = extractAssociationMetadataFromAssociationName(aliasOrExpression).alias;
+            associationAliasToColumnAliasMap[alias] ||= {};
+            const aliasedDreamClass = aliasToDreamClassesMap[alias];
+            const association = aliasToAssociationsMap[alias];
+            const columns = alias === this.baseSqlAlias
+                ? options.columns
+                    ? this.columnsWithRequiredLoadColumns(options.columns)
+                    : this.dreamClass.columns()
+                : aliasedDreamClass.columns();
+            columns.forEach((column) => {
+                const columnAlias = `dr${nextColumnAliasCounter++}`;
+                kyselyQuery = kyselyQuery.select(`${this.namespaceColumn(column, alias)} as ${columnAlias}`);
+                associationAliasToColumnAliasMap[alias][column] = columnAlias;
+            });
+            if (association?.type === 'HasOne' || association?.type === 'HasMany') {
+                const setupPreloadData = (dbColumnName) => {
+                    const columnAlias = `dr${nextColumnAliasCounter++}`;
+                    associationAliasToColumnAliasMap[association.through][dbColumnName] = columnAlias;
+                    kyselyQuery = kyselyQuery.select(`${this.namespaceColumn(dbColumnName, association.through)} as ${columnAlias}`);
+                };
+                if (association.through && association.preloadThroughColumns) {
+                    if (isObject(association.preloadThroughColumns)) {
+                        const preloadMap = association.preloadThroughColumns;
+                        Object.keys(preloadMap).forEach(columnName => setupPreloadData(columnName));
+                    }
+                    else {
+                        const preloadArray = association.preloadThroughColumns;
+                        preloadArray.forEach(columnName => setupPreloadData(columnName));
+                    }
+                }
+            }
+        });
+        const queryResults = await executeDatabaseQuery(kyselyQuery, 'execute');
+        const aliasToDreamIdMap = queryResults.reduce((aliasToDreamIdMap, singleSqlResult) => {
+            this.fleshOutJoinLoadExecutionResults({
+                currentAlias: this.baseSqlAlias,
+                singleSqlResult,
+                aliasToDreamIdMap,
+                associationAliasToColumnAliasMap,
+                aliasToAssociationsMap,
+                aliasToDreamClassesMap,
+                leftJoinStatements: this.leftJoinStatements,
+            });
+            return aliasToDreamIdMap;
+        }, {});
+        const baseModelIdToDreamMap = aliasToDreamIdMap[this.baseSqlAlias] || new Map();
+        return compact(Array.from(baseModelIdToDreamMap.values()));
+    }
+    fleshOutJoinLoadExecutionResults({ currentAlias, singleSqlResult, aliasToDreamIdMap, associationAliasToColumnAliasMap, aliasToAssociationsMap, aliasToDreamClassesMap, leftJoinStatements, }) {
+        const dreamClass = aliasToDreamClassesMap[currentAlias];
+        const columnToColumnAliasMap = associationAliasToColumnAliasMap[currentAlias];
+        const primaryKeyValue = singleSqlResult[columnToColumnAliasMap[dreamClass.primaryKey]];
+        if (!primaryKeyValue)
+            return null;
+        aliasToDreamIdMap[currentAlias] ||= new Map();
+        if (!aliasToDreamIdMap[currentAlias].get(primaryKeyValue)) {
+            const columnValueMap = Object.keys(columnToColumnAliasMap).reduce((columnNameValueMap, columnName) => {
+                columnNameValueMap[columnName] = singleSqlResult[columnToColumnAliasMap[columnName]];
+                return columnNameValueMap;
+            }, {});
+            const dream = sqlResultToDreamInstance(dreamClass, columnValueMap);
+            const association = aliasToAssociationsMap[currentAlias];
+            if (association && association.through && association.preloadThroughColumns) {
+                const throughAssociationColumnToColumnAliasMap = associationAliasToColumnAliasMap[association.through];
+                this.hydratePreloadedThroughColumns({
+                    association,
+                    columnToColumnAliasMap: throughAssociationColumnToColumnAliasMap,
+                    dream,
+                    singleSqlResult,
+                });
+            }
+            aliasToDreamIdMap[protectAgainstPollutingAssignment(currentAlias)].set(primaryKeyValue, dream);
+        }
+        const dream = aliasToDreamIdMap[currentAlias].get(primaryKeyValue);
+        Object.keys(leftJoinStatements).forEach(nextAlias => {
+            const { name: associationName, alias } = extractAssociationMetadataFromAssociationName(nextAlias);
+            const association = dreamClass['getAssociationMetadata'](associationName);
+            const associatedDream = this.fleshOutJoinLoadExecutionResults({
+                currentAlias: alias,
+                singleSqlResult,
+                aliasToDreamIdMap,
+                associationAliasToColumnAliasMap,
+                aliasToAssociationsMap,
+                aliasToDreamClassesMap,
+                leftJoinStatements: leftJoinStatements[nextAlias],
+            });
+            const hasMany = association.type === 'HasMany';
+            // initialize by trying to access the association, which throws an exception if not yet initialized
+            try {
+                ;
+                dream[association.as];
+            }
+            catch {
+                if (hasMany)
+                    dream[association.as] = [];
+                else
+                    dream[associationToGetterSetterProp(association)] = null;
+            }
+            if (!associatedDream)
+                return;
+            if (hasMany) {
+                if (!dream[association.as].includes(associatedDream))
+                    dream[association.as].push(associatedDream);
+            }
+            else
+                dream[associationToGetterSetterProp(association)] = associatedDream;
+        });
+        return dream;
+    }
+    hydratePreloadedThroughColumns({ association, columnToColumnAliasMap, dream, singleSqlResult, }) {
+        if (!association.through)
+            return;
+        if (!dream.preloadedThroughColumns)
+            return;
+        let columnNames = [];
+        const columnNameToPreloadedThroughColumnNameMap = {};
+        if (isObject(association.preloadThroughColumns)) {
+            const preloadMap = association.preloadThroughColumns;
+            columnNames = Object.keys(preloadMap).map(columnName => {
+                columnNameToPreloadedThroughColumnNameMap[columnName] = preloadMap[columnName];
+                return columnName;
+            });
+        }
+        else if (Array.isArray(association.preloadThroughColumns)) {
+            columnNames = association.preloadThroughColumns.map(columnName => {
+                columnNameToPreloadedThroughColumnNameMap[columnName] = columnName;
+                return columnName;
+            });
+        }
+        columnNames.forEach(columnName => (dream.preloadedThroughColumns[columnNameToPreloadedThroughColumnNameMap[columnName]] =
+            singleSqlResult[columnToColumnAliasMap[columnName]]));
+    }
+    /**
+     * Plucks the provided fields from the given dream class table
+     *
+     * ```ts
+     * await User.order('id').pluck('id')
+     * // [1, 2, 3]
+     * ```
+     *
+     * If more than one column is requested, a multi-dimensional
+     * array is returned:
+     *
+     * ```ts
+     * await User.order('id').pluck('id', 'email')
+     * // [[1, 'a@a.com'], [2, 'b@b.com']]
+     * ```
+     *
+     * @param columnNames - The column or array of columns to pluck
+     * @returns An array of pluck results
+     */
+    async pluck(...columnNames) {
+        const vals = await this.executePluck(...columnNames);
+        return (columnNames.length > 1 ? vals : vals.flat());
+    }
+    /**
+     * Plucks the specified column names from the given dream class table
+     * in batches, passing each found columns into the
+     * provided callback function
+     *
+     * ```ts
+     * await User.order('id').pluckEach('id', (id) => {
+     *   console.log(id)
+     * })
+     * // 1
+     * // 2
+     * // 3
+     * ```
+     *
+     * @param args - a list of column names to pluck, followed by a callback function to call for each set of found fields
+     * @returns void
+     */
+    async pluckEach(...args) {
+        const providedCbIndex = args.findIndex(v => typeof v === 'function');
+        const providedCb = args[providedCbIndex];
+        const providedOpts = args[providedCbIndex + 1];
+        if (!providedCb)
+            throw new MissingRequiredCallbackFunctionToPluckEach('pluckEach', args);
+        if (providedOpts !== undefined && !providedOpts?.batchSize)
+            throw new CannotPassAdditionalFieldsToPluckEachAfterCallback('pluckEach', args);
+        const onlyColumns = args.filter((_, index) => index < providedCbIndex);
+        const batchSize = providedOpts?.batchSize || Query.BATCH_SIZES.PLUCK_EACH_THROUGH;
+        let offset = 0;
+        let records;
+        do {
+            const onlyIncludesPrimaryKey = onlyColumns.find(column => column === this.dreamClass.primaryKey || column === this.namespacedPrimaryKey);
+            const columnsIncludingPrimaryKey = onlyIncludesPrimaryKey
+                ? onlyColumns
+                : [this.namespacedPrimaryKey, ...onlyColumns];
+            records = await this.offset(offset)
+                .order(null)
+                .order(this.namespacedPrimaryKey)
+                .limit(batchSize)
+                .executePluck(...columnsIncludingPrimaryKey);
+            // In order to batch, we need to order by primary key, so the primary key must be plucked.
+            // If the developer did not include the primary key in the columns to pluck, then we prepended it above
+            // and need to remove it from each group of plucked columns prior to passing them into the callback functions
+            const vals = onlyIncludesPrimaryKey ? records : records.map(valueArr => valueArr.slice(1));
+            for (const val of vals) {
+                await providedCb(...val);
+            }
+            offset += batchSize;
+        } while (records.length > 0 && records.length === batchSize);
+    }
+    /**
+     * Retrieves an array containing all records matching the Query.
+     * Be careful using this, since it will attempt to pull every
+     * record into memory at once. When querying might return a large
+     * number of records, consider using `.findEach`, which will pull
+     * the records in batches.
+     *
+     * ```ts
+     * await User.query().all()
+     * ```
+     *
+     * @returns an array of dreams
+     */
+    async all(options = {}) {
+        if (this.joinLoadActivated)
+            return await this.executeJoinLoad(options);
+        const kyselyQuery = this.buildSelect(options);
+        const results = await executeDatabaseQuery(kyselyQuery, 'execute');
+        const theAll = results.map(r => sqlResultToDreamInstance(this.dreamClass, r));
+        await this.applyPreload(this.preloadStatements, this.preloadOnStatements, theAll);
+        return theAll;
+    }
+    /**
+     * Forces use of a database connection (e.g. 'primary') during the query.
+     *
+     * NOTE: all queries within a transaction always use the 'primary' replica, so
+     * explicitly setting connection within a transaction has no effect.
+     *
+     * @param connection - The connection you wish to access ('primary' or 'replica')
+     * @returns A Query with the requested connection
+     */
+    connection(connection) {
+        return this._connection(connection);
+    }
+    _connection(connection) {
+        if (!connection)
+            return this;
+        return this.clone({ connection });
+    }
+    /**
+     * Returns true if a record exists for the given
+     * Query
+     *
+     * ```ts
+     * await User.query().exists()
+     * // false
+     *
+     * await User.create({ email: 'how@yadoin' })
+     *
+     * await User.query().exists()
+     * // true
+     * ```
+     *
+     * @returns boolean
+     */
+    async exists() {
+        // Implementing via `limit(1).all()`, rather than the simpler `!!(await this.first())`
+        // because it avoids the step of finding the first. Just find any, and return
+        // that one.
+        return (await this.limit(1).all()).length > 0;
+    }
+    /**
+     * Returns the first record in the database
+     * matching the Query. If the Query is not
+     * ordered, it will automatically order
+     * by primary key.
+     *
+     * ```ts
+     * await User.query().first()
+     * // User{id: 1}
+     * ```
+     *
+     * @returns First record in the database, or null if no record exists
+     */
+    async first() {
+        const query = this.orderStatements.length
+            ? this
+            : this.order({ [this.namespacedPrimaryKey]: 'asc' });
+        return await query.takeOne();
+    }
+    /**
+     * Returns the first record in the database
+     * matching the Query. If the Query is not
+     * ordered, it will automatically order
+     * by primary key. If no record is found,
+     * an exception is raised.
+     *
+     * ```ts
+     * await User.query().first()
+     * // User{id: 1}
+     * ```
+     *
+     * @returns First record in the database, or null if no record exists
+     */
+    async firstOrFail() {
+        const record = await this.first();
+        if (!record)
+            throw new RecordNotFound(this.dreamInstance.constructor.name);
+        return record;
+    }
+    /**
+     * Returns the last record in the database
+     * matching the Query. If the Query is not
+     * ordered, it will automatically order
+     * by primary key.
+     *
+     * ```ts
+     * await User.query().last()
+     * // User{id: 99}
+     * ```
+     *
+     * @returns Last record in the database, or null if no record exists
+     */
+    async last() {
+        const query = this.orderStatements.length
+            ? this.invertOrder()
+            : this.order({ [this.namespacedPrimaryKey]: 'desc' });
+        return await query.takeOne();
+    }
+    /**
+     * Returns the last record in the database
+     * matching the Query. If the Query is not
+     * ordered, it will automatically order
+     * by primary key. If no record is found,
+     * it will raise an exception.
+     *
+     * ```ts
+     * await User.where(...).lastOrFail()
+     * // User{id: 99}
+     * ```
+     *
+     * @returns Last record in the database, or null if no record exists
+     */
+    async lastOrFail() {
+        const record = await this.last();
+        if (!record)
+            throw new RecordNotFound(this.dreamInstance.constructor.name);
+        return record;
+    }
+    /**
+     * Destroys all records matching the Query,
+     * calling model hooks and cascading destroy
+     * to associations with `dependent: 'destroy'`,
+     * and returns the number of records that
+     * were destroyed.
+     *
+     * To delete in a single database query,
+     * ignoring model hooks and association
+     * dependent-destroy declarations, use
+     * {@link Query.delete | delete} instead.
+     *
+     * ```ts
+     * await User.where({ email: ops.ilike('%burpcollaborator%') }).destroy()
+     * // 12
+     * ```
+     *
+     * @param options - Options for destroying the instance
+     * @param options.skipHooks - If true, skips applying model hooks during the destroy operation. Defaults to false
+     * @param options.cascade - If false, skips destroying associations marked `dependent: 'destroy'`. Defaults to true
+     * @param options.bypassAllDefaultScopes - If true, bypasses all default scopes when cascade destroying. Defaults to false
+     * @param options.defaultScopesToBypass - An array of default scope names to bypass when cascade destroying. Defaults to an empty array
+     * @returns The number of records that were removed
+     */
+    async destroy({ skipHooks, cascade, } = {}) {
+        let counter = 0;
+        const options = {
+            bypassAllDefaultScopes: this.bypassAllDefaultScopes,
+            defaultScopesToBypass: this.defaultScopesToBypass,
+            skipHooks,
+            cascade,
+        };
+        await this.findEach(async (result) => {
+            const subquery = this.dreamTransaction
+                ? result.txn(this.dreamTransaction)
+                : result;
+            if (this.shouldReallyDestroy) {
+                await subquery.reallyDestroy(options);
+            }
+            else {
+                await subquery.destroy(options);
+            }
+            counter++;
+        });
+        return counter;
+    }
+    /**
+     * Destroys all records matching the Query,
+     * ignoring the SoftDelete decorator and
+     * permanently removing records from the database.
+     *
+     * Calls model hooks and applies cascade destroy
+     * to associations with `dependent: 'destroy'`,
+     * returning the number of records that
+     * were destroyed.
+     *
+     * To destroy without bypassing the SoftDelete
+     * decorator, use {@link Query.(destroy:instance) | destroy} instead.
+     *
+     * ```ts
+     * await User.where({ email: ops.ilike('%burpcollaborator%') }).reallyDestroy()
+     * // 12
+     * ```
+     *
+     * @param options - Options for destroying the instance
+     * @param options.skipHooks - If true, skips applying model hooks during the destroy operation. Defaults to false
+     * @param options.cascade - If false, skips destroying associations marked `dependent: 'destroy'`. Defaults to true
+     * @param options.bypassAllDefaultScopes - If true, bypasses all default scopes when cascade destroying. Defaults to false
+     * @param options.defaultScopesToBypass - An array of default scope names to bypass when cascade destroying. Defaults to an empty array
+     * @returns The number of records that were removed
+     */
+    async reallyDestroy({ skipHooks, cascade, } = {}) {
+        return await this.clone({ shouldReallyDestroy: true }).destroy({ skipHooks, cascade });
+    }
+    /**
+     * Undestroys a SoftDelete model, unsetting
+     * the `deletedAt` field in the database.
+     *
+     * If the model is not a SoftDelete model,
+     * this will raise an exception.
+     *
+     * ```ts
+     * await User.where({ email: ops.ilike('%burpcollaborator%') }).undestroy()
+     * // 12
+     * ```
+     *
+     * @param options - Options for undestroying the instance
+     * @param options.skipHooks - If true, skips applying model hooks during the undestroy operation. Defaults to false
+     * @param options.cascade - If false, skips undestroying associations marked `dependent: 'destroy'`. Defaults to true
+     * @param options.bypassAllDefaultScopes - If true, bypasses all default scopes when cascade undestroying. Defaults to false
+     * @param options.defaultScopesToBypass - An array of default scope names to bypass when cascade undestroying (soft delete is always bypassed). Defaults to an empty array
+     * @returns The number of records that were removed
+     */
+    async undestroy({ cascade, skipHooks, } = {}) {
+        if (!this.dreamClass['softDelete'])
+            throw new CannotCallUndestroyOnANonSoftDeleteModel(this.dreamClass);
+        let counter = 0;
+        await this.removeDefaultScope(SOFT_DELETE_SCOPE_NAME).findEach(async (result) => {
+            const subquery = this.dreamTransaction
+                ? result.txn(this.dreamTransaction)
+                : result;
+            await subquery.undestroy({
+                bypassAllDefaultScopes: this.bypassAllDefaultScopes,
+                defaultScopesToBypass: this.defaultScopesToBypass,
+                cascade,
+                skipHooks,
+            });
+            counter++;
+        });
+        return counter;
+    }
+    /**
+     * Deletes all records matching query using a single
+     * database query, but does not call underlying callbacks.
+     * Ignores association dependent destroy declarations,
+     * though cascading may still happen at the database level.
+     *
+     * To apply model hooks and association dependent destroy,
+     * use {@link Query.(destroy:instance) | destroy} instead.
+     *
+     * ```ts
+     * await User.where({ email: ops.ilike('%burpcollaborator%').delete() })
+     * // 12
+     * ```
+     *
+     * @returns The number of records that were removed
+     */
+    async delete() {
+        const deletionResult = await executeDatabaseQuery(this.buildDelete(), 'executeTakeFirst');
+        return Number(deletionResult?.numDeletedRows || 0);
+    }
+    /**
+     * Updates all records matching the Query
+     *
+     * ```ts
+     * await User.where({ email: ops.ilike('%burpcollaborator%') }).updateAll({ email: null })
+     * // 12
+     * ```
+     * @param attributes - The attributes used to update the records
+     * @param options - Options for updating the instance
+     * @param options.skipHooks - If true, skips applying model hooks. Defaults to false
+     * @returns The number of records that were updated
+     */
+    async update(attributes, { skipHooks } = {}) {
+        if (this.baseSelectQuery)
+            throw new NoUpdateOnAssociationQuery();
+        if (Object.keys(this.innerJoinStatements).length)
+            throw new NoUpdateAllOnJoins();
+        if (Object.keys(this.leftJoinStatements).length)
+            throw new NoUpdateAllOnJoins();
+        if (skipHooks)
+            return await this.updateWithoutCallingModelHooks(attributes);
+        let counter = 0;
+        await this.findEach(async (result) => {
+            const subquery = this.dreamTransaction
+                ? result.txn(this.dreamTransaction)
+                : result;
+            await subquery.update(attributes);
+            counter++;
+        });
+        return counter;
+    }
+    async updateWithoutCallingModelHooks(attributes) {
+        const kyselyQuery = this.buildUpdate(attributes);
+        const res = await executeDatabaseQuery(kyselyQuery, 'execute');
+        const resultData = Array.from(res.entries())?.[0]?.[1];
+        return Number(resultData?.numUpdatedRows || 0);
+    }
+    /**
+     * @internal
+     *
+     * Used for applying first and last queries
+     *
+     * @returns A dream instance or null
+     */
+    async takeOne() {
+        if (this.joinLoadActivated) {
+            let query;
+            if (this.whereStatements.find(whereStatement => whereStatement[this.dreamClass.primaryKey] ||
+                whereStatement[this.namespacedPrimaryKey])) {
+                // the query already includes a primary key where statement
+                query = this;
+            }
+            else {
+                // otherwise find the primary key and apply it to the query
+                const primaryKeyValue = (await this.limit(1).pluck(this.namespacedPrimaryKey))[0];
+                if (primaryKeyValue === undefined)
+                    return null;
+                query = this.where({ [this.namespacedPrimaryKey]: primaryKeyValue });
+            }
+            return (await query.executeJoinLoad())[0] || null;
+        }
+        const kyselyQuery = this.limit(1).buildSelect();
+        const results = await executeDatabaseQuery(kyselyQuery, 'executeTakeFirst');
+        if (results) {
+            const theFirst = sqlResultToDreamInstance(this.dreamClass, results);
+            if (theFirst)
+                await this.applyPreload(this.preloadStatements, this.preloadOnStatements, [theFirst]);
+            return theFirst;
+        }
+        else
+            return null;
+    }
+    /**
+     * @internal
+     *
+     * Used to hydrate dreams with the provided associations
+     */
+    hydrateAssociation(dreams, association, preloadedDreamsAndWhatTheyPointTo) {
+        switch (association.type) {
+            case 'HasMany':
+                dreams.forEach((dream) => {
+                    dream[association.as] = [];
+                });
+                break;
+            default:
+                dreams.forEach((dream) => {
+                    dream[associationToGetterSetterProp(association)] = null;
+                });
+        }
+        // dreams is a Rating
+        // Rating belongs to: rateables (Posts / Compositions)
+        // loadedAssociations is an array of Posts and Compositions
+        // if rating.rateable_id === loadedAssociation.primaryKeyvalue
+        //  rating.rateable = loadedAssociation
+        preloadedDreamsAndWhatTheyPointTo.forEach(preloadedDreamAndWhatItPointsTo => {
+            dreams
+                .filter(dream => dream.primaryKeyValue === preloadedDreamAndWhatItPointsTo.pointsToPrimaryKey)
+                .forEach((dream) => {
+                if (association.type === 'HasMany') {
+                    dream[association.as].push(preloadedDreamAndWhatItPointsTo.dream);
+                }
+                else {
+                    // in a HasOne context, order clauses will be applied in advance,
+                    // prior to hydration. Considering, we only want to set the first
+                    // result and ignore other results, so we will use ||= to set.
+                    dream[association.as] ||= preloadedDreamAndWhatItPointsTo.dream;
+                }
+            });
+        });
+        if (association.type === 'HasMany') {
+            dreams.forEach((dream) => Object.freeze(dream[association.as]));
+        }
+    }
+    /**
+     * @internal
+     *
+     * Used to bridge through associations
+     */
+    followThroughAssociation(dreamClass, association) {
+        const throughAssociation = association.through && dreamClass['getAssociationMetadata'](association.through);
+        if (!throughAssociation)
+            throw new MissingThroughAssociation({
+                dreamClass,
+                association,
+            });
+        const throughClass = throughAssociation.modelCB();
+        if (Array.isArray(throughClass))
+            throw new CannotAssociateThroughPolymorphic({
+                dreamClass,
+                association,
+            });
+        const newAssociation = getSourceAssociation(throughClass, association.source);
+        if (!newAssociation)
+            throw new MissingThroughAssociationSource({
+                dreamClass,
+                throughClass,
+                association,
+            });
+        return { throughAssociation, throughClass, newAssociation };
+    }
+    /**
+     * @internal
+     *
+     * Polymorphic BelongsTo. Since polymorphic associations may point to multiple tables,
+     * preload by loading each target class separately.
+     *
+     * Used to preload polymorphic belongs to associations
+     */
+    async preloadPolymorphicBelongsTo(association, dreams) {
+        if (!association.polymorphic)
+            throw new Error(`Association ${association.as} points to an array of models but is not designated polymorphic`);
+        if (association.type !== 'BelongsTo')
+            throw new Error(`Polymorphic association ${association.as} points to an array of models but is ${association.type}. Only BelongsTo associations may point to an array of models.`);
+        const associatedDreams = [];
+        for (const associatedModel of association.modelCB()) {
+            await this.preloadPolymorphicAssociationModel(dreams, association, associatedModel, associatedDreams);
+        }
+        return associatedDreams;
+    }
+    async preloadPolymorphicAssociationModel(dreams, association, associatedDreamClass, associatedDreams) {
+        const relevantAssociatedModels = dreams.filter((dream) => {
+            return dream[association.foreignKeyTypeField()] === associatedDreamClass['stiBaseClassOrOwnClass'].name;
+        });
+        if (relevantAssociatedModels.length) {
+            dreams.forEach((dream) => {
+                dream[associationToGetterSetterProp(association)] = null;
+            });
+            // Load all models of type associated that are associated with any of the already loaded Dream models
+            const loadedAssociations = await this.dreamClassQueryWithScopeBypasses(associatedDreamClass, {
+                // The association may remove specific default scopes that would otherwise preclude
+                // certain instances of the associated class from being found.
+                defaultScopesToBypassExceptOnAssociations: association.withoutDefaultScopes,
+            })
+                .where({
+                [associatedDreamClass.primaryKey]: relevantAssociatedModels.map((dream) => dream[association.foreignKey()]),
+            })
+                .all();
+            loadedAssociations.forEach((loadedAssociation) => associatedDreams.push(loadedAssociation));
+            //////////////////////////////////////////////////////////////////////////////////////////////
+            // Associate each loaded association with each dream based on primary key and foreign key type
+            //////////////////////////////////////////////////////////////////////////////////////////////
+            for (const loadedAssociation of loadedAssociations) {
+                dreams
+                    .filter((dream) => {
+                    return (dream[association.foreignKeyTypeField()] === loadedAssociation['stiBaseClassOrOwnClass'].name &&
+                        dream[association.foreignKey()] === association.primaryKeyValue(loadedAssociation));
+                })
+                    .forEach((dream) => {
+                    dream[association.as] = loadedAssociation;
+                });
+            }
+            ///////////////////////////////////////////////////////////////////////////////////////////////////
+            // end: Associate each loaded association with each dream based on primary key and foreign key type
+            ///////////////////////////////////////////////////////////////////////////////////////////////////
+        }
+    }
+    /**
+     * @internal
+     *
+     * Applies a preload statement
+     */
+    async applyOnePreload(associationName, dreams, onStatement = {}) {
+        if (!Array.isArray(dreams))
+            dreams = [dreams];
+        const dream = dreams.find(dream => dream['getAssociationMetadata'](associationName));
+        if (!dream)
+            return;
+        const association = dream['getAssociationMetadata'](associationName);
+        const dreamClass = dream.constructor;
+        const dreamClassToHydrate = association.modelCB();
+        if ((association.polymorphic && association.type === 'BelongsTo') || Array.isArray(dreamClassToHydrate))
+            return this.preloadPolymorphicBelongsTo(association, dreams);
+        const dreamClassToHydrateColumns = [...dreamClassToHydrate.columns()];
+        const throughColumnsToHydrate = [];
+        const columnsToPluck = dreamClassToHydrateColumns.map(column => this.namespaceColumn(column.toString(), associationName));
+        const asHasAssociation = association;
+        if (asHasAssociation.through && asHasAssociation.preloadThroughColumns) {
+            if (isObject(asHasAssociation.preloadThroughColumns)) {
+                const preloadMap = asHasAssociation.preloadThroughColumns;
+                Object.keys(preloadMap).forEach(preloadThroughColumn => {
+                    throughColumnsToHydrate.push(preloadMap[preloadThroughColumn]);
+                    columnsToPluck.push(this.namespaceColumn(preloadThroughColumn, asHasAssociation.through));
+                });
+            }
+            else {
+                const preloadArray = asHasAssociation.preloadThroughColumns;
+                preloadArray.forEach(preloadThroughColumn => {
+                    throughColumnsToHydrate.push(preloadThroughColumn);
+                    columnsToPluck.push(this.namespaceColumn(preloadThroughColumn, asHasAssociation.through));
+                });
+            }
+        }
+        columnsToPluck.push(this.namespaceColumn(dreamClass.primaryKey, dreamClass.table));
+        const baseClass = dreamClass['stiBaseClassOrOwnClass']['getAssociationMetadata'](associationName)
+            ? dreamClass['stiBaseClassOrOwnClass']
+            : dreamClass;
+        const associationDataScope = this.dreamClassQueryWithScopeBypasses(baseClass, {
+            // In order to stay DRY, preloading leverages the association logic built into
+            // `joins` (by using `pluck`, which calls `joins`). However, baseClass may have
+            // default scopes that would preclude finding that instance. We remove all
+            // default scopes on baseClass, but not subsequent associations, so that the
+            // single query will be able to find each row corresponding to a Dream in `dreams`,
+            // regardless of default scopes on that Dream's class.
+            bypassAllDefaultScopesExceptOnAssociations: true,
+        }).where({
+            [dreamClass.primaryKey]: dreams.map(obj => obj.primaryKeyValue),
+        });
+        const hydrationData = await associationDataScope
+            ._connection(this.connectionOverride)
+            .innerJoin(associationName, (onStatement || {}))
+            .pluck(...columnsToPluck);
+        const preloadedDreamsAndWhatTheyPointTo = hydrationData.map(pluckedData => {
+            const attributes = {};
+            dreamClassToHydrateColumns.forEach((columnName, index) => (attributes[protectAgainstPollutingAssignment(columnName)] = pluckedData[index]));
+            const hydratedDream = sqlResultToDreamInstance(dreamClassToHydrate, attributes);
+            throughColumnsToHydrate.forEach((throughAssociationColumn, index) => (hydratedDream.preloadedThroughColumns[throughAssociationColumn] =
+                pluckedData[dreamClassToHydrateColumns.length + index]));
+            return {
+                dream: hydratedDream,
+                pointsToPrimaryKey: pluckedData[pluckedData.length - 1],
+            };
+        });
+        this.hydrateAssociation(dreams, association, preloadedDreamsAndWhatTheyPointTo);
+        return preloadedDreamsAndWhatTheyPointTo.map(obj => obj.dream);
+    }
+    /**
+     * @internal
+     *
+     * Used by loadBuider
+     */
+    async hydratePreload(dream) {
+        await this.applyPreload(this.preloadStatements, this.preloadOnStatements, dream);
+    }
+    /**
+     * @internal
+     *
+     * Applies a preload statement
+     */
+    async applyPreload(preloadStatement, preloadOnStatements, dream) {
+        const keys = Object.keys(preloadStatement);
+        for (const key of keys) {
+            const nestedDreams = await this.applyOnePreload(key, dream, this.applyablePreloadOnStatements(preloadOnStatements[key]));
+            if (nestedDreams) {
+                await this.applyPreload(preloadStatement[key], preloadOnStatements[key], nestedDreams);
+            }
+        }
+    }
+    /**
+     * @internal
+     *
+     * retrieves on statements that can be applied to a preload
+     */
+    applyablePreloadOnStatements(preloadOnStatements) {
+        if (preloadOnStatements === undefined)
+            return undefined;
+        return Object.keys(preloadOnStatements).reduce((agg, key) => {
+            const value = preloadOnStatements[key];
+            // filter out plain objects, but not ops and not on/notOn/onAny statements
+            // because plain objects are just the next level of nested preload
+            if (key === 'on' ||
+                key === 'notOn' ||
+                key === 'onAny' ||
+                value === null ||
+                value.constructor !== Object) {
+                agg[key] = value;
+            }
+            return agg;
+        }, {});
+    }
+    conditionallyApplyDefaultScopes() {
+        if (this.bypassAllDefaultScopes || this.bypassAllDefaultScopesExceptOnAssociations)
+            return this;
+        const thisScopes = this.dreamClass['scopes'].default;
+        let query = this;
+        for (const scope of thisScopes) {
+            if (!shouldBypassDefaultScope(scope.method, {
+                defaultScopesToBypass: [
+                    ...this.defaultScopesToBypass,
+                    ...this.defaultScopesToBypassExceptOnAssociations,
+                ],
+            })) {
+                query = this.dreamClass[scope.method](query);
+            }
+        }
+        return query;
+    }
+    // Through associations don't get written into the SQL; they
+    // locate the next association we need to build into the SQL
+    // AND the source to reference on the other side
+    joinsBridgeThroughAssociations({ query, dreamClass, association, previousAssociationTableOrAlias, throughAssociations, joinType, }) {
+        if (association.type === 'BelongsTo' || !association.through) {
+            return {
+                query,
+                dreamClass,
+                association,
+                previousAssociationTableOrAlias,
+            };
+        }
+        else {
+            throughAssociations.push(association);
+            // We have entered joinsBridgeThroughAssociations with the
+            // CompositionAssetAudits HasOne User association, which
+            // is through compositionAsset
+            // We now apply the compositionAsset association (a BelongsTo)
+            // to the query
+            const { query: queryWithThroughAssociationApplied } = this.applyOneJoin({
+                query,
+                dreamClass,
+                previousAssociationTableOrAlias,
+                currentAssociationTableOrAlias: association.through,
+                throughAssociations,
+                joinType,
+            });
+            // The through association has both a `through` and a `source`. The `source`
+            // is the association on the model that has now been joined. In our example,
+            // the `source` is the `user` association on the CompositionAsset model
+            const { newAssociation, throughAssociation, throughClass } = this.followThroughAssociation(dreamClass, association);
+            if (newAssociation.through) {
+                // This new association is itself a through association, so we recursively
+                // call joinsBridgeThroughAssociations
+                return this.joinsBridgeThroughAssociations({
+                    query: queryWithThroughAssociationApplied,
+                    dreamClass: throughClass,
+                    association: newAssociation,
+                    previousAssociationTableOrAlias: throughAssociation.as,
+                    throughAssociations,
+                    joinType,
+                });
+            }
+            else {
+                // This new association is not a through association, so
+                // this is the target association we were looking for
+                return {
+                    query: queryWithThroughAssociationApplied,
+                    dreamClass: association.modelCB(),
+                    association: newAssociation,
+                    throughClass,
+                    previousAssociationTableOrAlias: association.through,
+                };
+            }
+        }
+    }
+    applyOneJoin({ query, dreamClass, previousAssociationTableOrAlias, currentAssociationTableOrAlias, joinOnStatements = {}, throughAssociations = [], joinType, }) {
+        const { name, alias } = extractAssociationMetadataFromAssociationName(currentAssociationTableOrAlias);
+        previousAssociationTableOrAlias = extractAssociationMetadataFromAssociationName(previousAssociationTableOrAlias).alias;
+        currentAssociationTableOrAlias = alias;
+        let association = dreamClass['getAssociationMetadata'](name);
+        if (!association) {
+            throw new JoinAttemptedOnMissingAssociation({
+                dreamClass,
+                associationName: currentAssociationTableOrAlias,
+            });
+        }
+        const results = this.joinsBridgeThroughAssociations({
+            query,
+            dreamClass,
+            association,
+            previousAssociationTableOrAlias,
+            throughAssociations,
+            joinType,
+        });
+        query = results.query;
+        dreamClass = results.dreamClass;
+        association = results.association;
+        const timeToApplyThroughAssociations = throughAssociations.length && throughAssociations[0].source === association.as;
+        const originalPreviousAssociationTableOrAlias = previousAssociationTableOrAlias;
+        previousAssociationTableOrAlias = results.previousAssociationTableOrAlias;
+        const throughClass = results.throughClass;
+        if (timeToApplyThroughAssociations) {
+            ///////////////////////////////////////////////////////////////////////////////////////
+            // when an association is through another association, `joinsBridgeThroughAssociations`
+            // is called, which eventually calls back to this method, passing in the original
+            // through association as `originalAssociation`
+            ///////////////////////////////////////////////////////////////////////////////////////
+            throughAssociations.forEach((throughAssociation) => {
+                if (throughAssociation.type === 'HasMany') {
+                    if (query?.distinctOn && throughAssociation.distinct) {
+                        query = query.distinctOn(this.distinctColumnNameForAssociation({
+                            association: throughAssociation,
+                            tableNameOrAlias: throughAssociation.as,
+                            foreignKey: throughAssociation.primaryKey(),
+                        }));
+                    }
+                    if (throughAssociation.order) {
+                        query = this.applyOrderStatementForAssociation({
+                            query,
+                            tableNameOrAlias: throughAssociation.as,
+                            association: throughAssociation,
+                        });
+                    }
+                }
+            });
+        }
+        if (association.type === 'BelongsTo') {
+            if (Array.isArray(association.modelCB()))
+                throw new CannotJoinPolymorphicBelongsToError({
+                    dreamClass,
+                    association,
+                    innerJoinStatements: this.innerJoinStatements,
+                    leftJoinStatements: this.leftJoinStatements,
+                });
+            const to = association.modelCB().table;
+            const joinTableExpression = currentAssociationTableOrAlias === to
+                ? currentAssociationTableOrAlias
+                : `${to} as ${currentAssociationTableOrAlias}`;
+            query = query[(joinType === 'inner' ? 'innerJoin' : 'leftJoin')](joinTableExpression, (join) => {
+                join = join.onRef(this.namespaceColumn(association.foreignKey(), previousAssociationTableOrAlias), '=', this.namespaceColumn(association.primaryKey(), currentAssociationTableOrAlias));
+                if (timeToApplyThroughAssociations) {
+                    throughAssociations.forEach((throughAssociation) => {
+                        join = this.applyAssociationOnStatementsToJoinStatement({
+                            join,
+                            association: throughAssociation,
+                            currentAssociationTableOrAlias,
+                            previousAssociationTableOrAlias: originalPreviousAssociationTableOrAlias,
+                            joinOnStatements,
+                        });
+                    });
+                }
+                join = this.conditionallyApplyDefaultScopesDependentOnAssociation({
+                    join,
+                    tableNameOrAlias: currentAssociationTableOrAlias,
+                    association,
+                });
+                join = this.applyJoinOnStatements(join, joinOnStatements[currentAssociationTableOrAlias], currentAssociationTableOrAlias);
+                return join;
+            });
+        }
+        else {
+            const to = association.modelCB().table;
+            const joinTableExpression = currentAssociationTableOrAlias === to
+                ? currentAssociationTableOrAlias
+                : `${to} as ${currentAssociationTableOrAlias}`;
+            query = query[(joinType === 'inner' ? 'innerJoin' : 'leftJoin')](joinTableExpression, (join) => {
+                join = join.onRef(this.namespaceColumn(association.primaryKey(), previousAssociationTableOrAlias), '=', this.namespaceColumn(association.foreignKey(), currentAssociationTableOrAlias));
+                if (association.polymorphic) {
+                    join = join.on((eb) => this.whereStatementToExpressionWrapper(eb, this.aliasWhereStatement({
+                        [association.foreignKeyTypeField()]: throughClass
+                            ? throughClass['stiBaseClassOrOwnClass'].name
+                            : dreamClass['stiBaseClassOrOwnClass'].name,
+                    }, currentAssociationTableOrAlias)));
+                }
+                if (timeToApplyThroughAssociations) {
+                    throughAssociations.forEach((throughAssociation) => {
+                        join = this.applyAssociationOnStatementsToJoinStatement({
+                            join,
+                            association: throughAssociation,
+                            currentAssociationTableOrAlias,
+                            previousAssociationTableOrAlias: originalPreviousAssociationTableOrAlias,
+                            joinOnStatements,
+                        });
+                    });
+                }
+                join = this.applyAssociationOnStatementsToJoinStatement({
+                    join,
+                    association,
+                    currentAssociationTableOrAlias,
+                    previousAssociationTableOrAlias,
+                    joinOnStatements,
+                });
+                join = this.conditionallyApplyDefaultScopesDependentOnAssociation({
+                    join,
+                    tableNameOrAlias: currentAssociationTableOrAlias,
+                    association,
+                });
+                join = this.applyJoinOnStatements(join, joinOnStatements[currentAssociationTableOrAlias], currentAssociationTableOrAlias);
+                return join;
+            });
+            if (association.type === 'HasMany') {
+                if (association.order) {
+                    query = this.applyOrderStatementForAssociation({
+                        query,
+                        tableNameOrAlias: currentAssociationTableOrAlias,
+                        association,
+                    });
+                }
+                if (query.distinctOn && association.distinct) {
+                    query = query.distinctOn(this.distinctColumnNameForAssociation({
+                        association,
+                        tableNameOrAlias: currentAssociationTableOrAlias,
+                        foreignKey: association.foreignKey(),
+                    }));
+                }
+            }
+        }
+        return {
+            query,
+            association,
+            previousAssociationTableOrAlias,
+            currentAssociationTableOrAlias,
+        };
+    }
+    applyAssociationOnStatementsToJoinStatement({ join, currentAssociationTableOrAlias, previousAssociationTableOrAlias, association, joinOnStatements, }) {
+        if (association.on) {
+            this.throwUnlessAllRequiredWhereClausesProvided(association, currentAssociationTableOrAlias, joinOnStatements);
+            join = join.on((eb) => this.whereStatementToExpressionWrapper(eb, this.aliasWhereStatement(association.on, currentAssociationTableOrAlias), { disallowSimilarityOperator: false }));
+        }
+        if (association.notOn) {
+            join = join.on((eb) => this.whereStatementToExpressionWrapper(eb, this.aliasWhereStatement(association.notOn, currentAssociationTableOrAlias), { negate: true }));
+        }
+        if (association.onAny) {
+            join = join.on((eb) => eb.or(association.onAny.map(whereAnyStatement => this.whereStatementToExpressionWrapper(eb, this.aliasWhereStatement(whereAnyStatement, currentAssociationTableOrAlias), { disallowSimilarityOperator: false }))));
+        }
+        if (association.selfOn) {
+            join = join.on((eb) => this.whereStatementToExpressionWrapper(eb, this.rawifiedSelfOnClause({
+                associationAlias: association.as,
+                selfAlias: previousAssociationTableOrAlias,
+                selfOnClause: association.selfOn,
+            })));
+        }
+        if (association.selfNotOn) {
+            join = join.on((eb) => this.whereStatementToExpressionWrapper(eb, this.rawifiedSelfOnClause({
+                associationAlias: association.as,
+                selfAlias: previousAssociationTableOrAlias,
+                selfOnClause: association.selfNotOn,
+            }), { negate: true }));
+        }
+        return join;
+    }
+    conditionallyApplyDefaultScopesDependentOnAssociation({ join, tableNameOrAlias, association, }) {
+        let scopesQuery = new Query(this.dreamInstance);
+        const associationClass = association.modelCB();
+        const associationScopes = associationClass['scopes'].default;
+        for (const scope of associationScopes) {
+            if (!shouldBypassDefaultScope(scope.method, {
+                bypassAllDefaultScopes: this.bypassAllDefaultScopes,
+                defaultScopesToBypass: [...this.defaultScopesToBypass, ...(association.withoutDefaultScopes || [])],
+            })) {
+                const tempQuery = associationClass[scope.method](scopesQuery);
+                // The scope method on a Dream model should return a clone of the Query it receives
+                // (e.g. by returning `scope.where(...)`), but in case the function doesn't return,
+                // or returns the wrong thing, we check before overriding `scopesQuery` with what the
+                // method returned.
+                if (tempQuery && tempQuery.constructor === scopesQuery.constructor)
+                    scopesQuery = tempQuery;
+            }
+        }
+        if (scopesQuery.whereStatements.length) {
+            join = join.on((eb) => eb.and(scopesQuery.whereStatements.flatMap(whereStatement => this.whereStatementToExpressionWrapper(eb, this.aliasWhereStatement(whereStatement, tableNameOrAlias), { disallowSimilarityOperator: false }))));
+        }
+        return join;
+    }
+    distinctColumnNameForAssociation({ association, tableNameOrAlias, foreignKey, }) {
+        if (!association.distinct)
+            return null;
+        if (association.distinct === true)
+            return this.namespaceColumn(foreignKey, tableNameOrAlias);
+        return this.namespaceColumn(association.distinct, tableNameOrAlias);
+    }
+    recursivelyJoin({ query, joinsStatement, joinOnStatements, dreamClass, previousAssociationTableOrAlias, joinType, }) {
+        for (const currentAssociationTableOrAlias of Object.keys(joinsStatement)) {
+            const results = this.applyOneJoin({
+                query,
+                dreamClass,
+                previousAssociationTableOrAlias,
+                currentAssociationTableOrAlias,
+                joinOnStatements,
+                joinType,
+            });
+            query = results.query;
+            const association = results.association;
+            query = this.recursivelyJoin({
+                query,
+                joinsStatement: joinsStatement[currentAssociationTableOrAlias],
+                joinOnStatements: joinOnStatements[currentAssociationTableOrAlias],
+                dreamClass: association.modelCB(),
+                previousAssociationTableOrAlias: currentAssociationTableOrAlias,
+                joinType,
+            });
+        }
+        return query;
+    }
+    throwUnlessAllRequiredWhereClausesProvided(association, namespace, joinOnStatements) {
+        const whereStatement = association.on;
+        const columnsRequiringWhereStatements = Object.keys(whereStatement).reduce((agg, column) => {
+            if (whereStatement[column] === DreamConst.required)
+                agg.push(column);
+            return agg;
+        }, []);
+        const missingRequiredWhereStatements = columnsRequiringWhereStatements.filter(column => joinOnStatements[namespace]?.on?.[column] === undefined);
+        if (missingRequiredWhereStatements.length)
+            throw new MissingRequiredAssociationOnClause(association, missingRequiredWhereStatements[0]);
+    }
+    applyOrderStatementForAssociation({ query, tableNameOrAlias, association, }) {
+        if (!query.orderBy)
+            return query;
+        let selectQuery = query;
+        const orderStatement = association.order;
+        if (isString(orderStatement)) {
+            selectQuery = selectQuery.orderBy(this.namespaceColumn(orderStatement, tableNameOrAlias), 'asc');
+        }
+        else {
+            Object.keys(orderStatement).forEach(column => {
+                const direction = orderStatement[column];
+                selectQuery = selectQuery.orderBy(this.namespaceColumn(column, tableNameOrAlias), direction);
+            });
+        }
+        return selectQuery;
+    }
+    inArrayWithNull_or_notInArrayWithoutNull_ExpressionBuilder(eb, a, b, c) {
+        const isNullStatement = eb(a, 'is', null);
+        const compactedC = compact(c);
+        if (compactedC.length)
+            return eb.or([eb(a, b, compactedC), isNullStatement]);
+        // not in an empty array means match everything
+        if (b === 'not in')
+            return sql `TRUE`;
+        return isNullStatement;
+    }
+    inArrayWithoutNullExpressionBuilder(eb, a, b, c) {
+        const isNotNullStatement = eb(a, 'is not', null);
+        const compactedC = compact(c);
+        if (compactedC.length)
+            return eb.and([eb(a, 'in', compactedC), isNotNullStatement]);
+        // in an empty array means match nothing
+        return sql `FALSE`;
+    }
+    notInArrayWithNullExpressionBuilder(eb, a, b, c) {
+        const isNullStatement = eb(a, 'is not', null);
+        const compactedC = compact(c);
+        if (compactedC.length)
+            return eb.and([eb(a, 'not in', compactedC), isNullStatement]);
+        return isNullStatement;
+    }
+    whereStatementToExpressionWrapper(eb, whereStatement, { negate = false, disallowSimilarityOperator = true, } = {}) {
+        const clauses = compact(Object.keys(whereStatement)
+            .filter(key => whereStatement[key] !== DreamConst.required)
+            .map(attr => {
+            const val = whereStatement[attr];
+            if (val?.isOpsStatement &&
+                val.shouldBypassWhereStatement) {
+                if (disallowSimilarityOperator)
+                    throw new Error('Similarity operator may not be used in whereAny');
+                // some ops statements are handled specifically in the select portion of the query,
+                // and should be ommited from the where clause directly
+                return;
+            }
+            const { a, b, c, a2, b2, c2 } = this.dreamWhereStatementToExpressionBuilderParts(attr, val);
+            // postgres is unable to handle WHERE IN statements with blank arrays, such as in
+            // "WHERE id IN ()", meaning that:
+            // 1. If we receive a blank array during an IN comparison,
+            //    then we need to simply regurgitate a where statement which
+            //    guarantees no records.
+            // 2. If we receive a blank array during a NOT IN comparison,
+            //    then it is the same as the where statement not being present at all,
+            //    resulting in a noop on our end
+            //
+            if (Array.isArray(c)) {
+                if ((b === 'in' && c.includes(null)) || (b === 'not in' && !c.includes(null))) {
+                    return this.inArrayWithNull_or_notInArrayWithoutNull_ExpressionBuilder(eb, a, b, c);
+                }
+                else if (negate && b === 'in' && !c.includes(null)) {
+                    return this.inArrayWithoutNullExpressionBuilder(eb, a, b, c);
+                }
+                else if (b === 'not in' && c.includes(null)) {
+                    return this.notInArrayWithNullExpressionBuilder(eb, a, b, c);
+                }
+                const compactedC = compact(c);
+                if (b === 'in' && compactedC.length === 0) {
+                    // in an empty array means match nothing
+                    return sql `FALSE`;
+                }
+                else if (b === 'not in' && compactedC.length === 0) {
+                    // not in an empty array means match everything
+                    return sql `TRUE`;
+                }
+                else {
+                    return eb(a, b, compactedC);
+                }
+                //
+            }
+            else if (b === '=' && c === null) {
+                return eb(a, 'is', null);
+                //
+            }
+            else if (b === '!=' && c === null) {
+                return eb(a, 'is not', null);
+                //
+            }
+            else if (b === '=' && negate) {
+                return eb.and([eb(a, '=', c), eb(a, 'is not', null)]);
+                //
+            }
+            else if (b === '!=' && c !== null) {
+                return eb.or([eb(a, '!=', c), eb(a, 'is', null)]);
+                //
+            }
+            else {
+                const expression = eb(a, b, c);
+                if (b2)
+                    return expression.and(eb(a2, b2, c2));
+                return expression;
+            }
+        }));
+        return negate ? eb.not(eb.parens(eb.and(clauses))) : eb.and(clauses);
+    }
+    dreamWhereStatementToExpressionBuilderParts(attr, val) {
+        let a;
+        let b;
+        let c;
+        let a2 = null;
+        let b2 = null;
+        let c2 = null;
+        if (val instanceof Function && val !== DreamConst.passthrough) {
+            val = val();
+        }
+        else if (val === DreamConst.passthrough) {
+            const column = attr.split('.').pop();
+            if (this.passthroughOnStatement[column] === undefined)
+                throw new MissingRequiredPassthroughForAssociationOnClause(column);
+            val = this.passthroughOnStatement[column];
+        }
+        if (val === null) {
+            a = attr;
+            b = 'is';
+            c = val;
+        }
+        else if (['SelectQueryBuilder', 'SelectQueryBuilderImpl'].includes(val?.constructor?.name)) {
+            a = attr;
+            b = 'in';
+            c = val;
+        }
+        else if (Array.isArray(val)) {
+            a = attr;
+            b = 'in';
+            c = val;
+        }
+        else if (val instanceof CurriedOpsStatement) {
+            val = val.toOpsStatement(this.dreamClass, attr);
+            a = attr;
+            b = val.operator;
+            c = val.value;
+        }
+        else if (val instanceof OpsStatement) {
+            a = attr;
+            b = val.operator;
+            c = val.value;
+        }
+        else if (val instanceof Range) {
+            const rangeStart = val.begin;
+            const rangeEnd = val.end;
+            const excludeEnd = val.excludeEnd;
+            if (rangeStart && rangeEnd) {
+                a = attr;
+                b = '>=';
+                c = rangeStart;
+                a2 = attr;
+                b2 = excludeEnd ? '<' : '<=';
+                c2 = rangeEnd;
+            }
+            else if (rangeStart) {
+                a = attr;
+                b = '>=';
+                c = rangeStart;
+            }
+            else {
+                a = attr;
+                b = excludeEnd ? '<' : '<=';
+                c = rangeEnd;
+            }
+        }
+        else {
+            a = attr;
+            b = '=';
+            c = val;
+        }
+        if (c instanceof DateTime || c instanceof CalendarDate)
+            c = c.toJSDate();
+        if (c2 instanceof DateTime || c2 instanceof CalendarDate)
+            c2 = c2.toJSDate();
+        if (a && c === undefined)
+            throw new CannotPassUndefinedAsAValueToAWhereClause(this.dreamClass, a);
+        if (a2 && c2 === undefined)
+            throw new CannotPassUndefinedAsAValueToAWhereClause(this.dreamClass, a2);
+        return { a, b, c, a2, b2, c2 };
+    }
+    applyJoinOnStatements(join, joinOnStatement, rootTableOrAssociationAlias) {
+        if (!joinOnStatement)
+            return join;
+        join = this._applyJoinOnStatements(join, joinOnStatement.on, rootTableOrAssociationAlias);
+        join = this._applyJoinOnStatements(join, joinOnStatement.notOn, rootTableOrAssociationAlias, {
+            negate: true,
+        });
+        join = this._applyJoinOnAnyStatements(join, joinOnStatement.onAny, rootTableOrAssociationAlias);
+        return join;
+    }
+    _applyJoinOnStatements(join, joinOnStatement, rootTableOrAssociationAlias, { negate = false, } = {}) {
+        if (!joinOnStatement)
+            return join;
+        return join.on((eb) => this.joinOnStatementToExpressionWrapper(joinOnStatement, rootTableOrAssociationAlias, eb, {
+            negate,
+            disallowSimilarityOperator: negate,
+        }));
+    }
+    _applyJoinOnAnyStatements(join, joinOnAnyStatement, rootTableOrAssociationAlias) {
+        if (!joinOnAnyStatement)
+            return join;
+        if (!joinOnAnyStatement.length)
+            return join;
+        return join.on((eb) => {
+            return eb.or(joinOnAnyStatement.map(joinOnStatement => this.joinOnStatementToExpressionWrapper(joinOnStatement, rootTableOrAssociationAlias, eb)));
+        });
+    }
+    joinOnStatementToExpressionWrapper(joinOnStatement, rootTableOrAssociationAlias, eb, { negate = false, disallowSimilarityOperator = true, } = {}) {
+        return this.whereStatementToExpressionWrapper(eb, Object.keys(joinOnStatement).reduce((agg, key) => {
+            agg[this.namespaceColumn(key.toString(), rootTableOrAssociationAlias)] = joinOnStatement[key];
+            return agg;
+        }, {}), {
+            negate,
+            disallowSimilarityOperator,
+        });
+    }
+    buildCommon(kyselyQuery) {
+        this.checkForQueryViolations();
+        const query = this.conditionallyApplyDefaultScopes();
+        if (!isEmpty(query.innerJoinStatements)) {
+            kyselyQuery = query.recursivelyJoin({
+                query: kyselyQuery,
+                joinsStatement: query.innerJoinStatements,
+                joinOnStatements: query.innerJoinOnStatements,
+                dreamClass: query.dreamClass,
+                previousAssociationTableOrAlias: this.baseSqlAlias,
+                joinType: 'inner',
+            });
+        }
+        if (!isEmpty(query.leftJoinStatements)) {
+            kyselyQuery = query.recursivelyJoin({
+                query: kyselyQuery,
+                joinsStatement: query.leftJoinStatements,
+                joinOnStatements: query.leftJoinOnStatements,
+                dreamClass: query.dreamClass,
+                previousAssociationTableOrAlias: this.baseSqlAlias,
+                joinType: 'left',
+            });
+        }
+        if (query.whereStatements.length || query.whereNotStatements.length || query.whereAnyStatements.length) {
+            kyselyQuery = kyselyQuery.where((eb) => eb.and([
+                ...this.aliasWhereStatements(query.whereStatements, query.baseSqlAlias).map(whereStatement => this.whereStatementToExpressionWrapper(eb, whereStatement, {
+                    disallowSimilarityOperator: false,
+                })),
+                ...this.aliasWhereStatements(query.whereNotStatements, query.baseSqlAlias).map(whereNotStatement => this.whereStatementToExpressionWrapper(eb, whereNotStatement, { negate: true })),
+                ...query.whereAnyStatements.map(whereAnyStatements => eb.or(this.aliasWhereStatements(whereAnyStatements, query.baseSqlAlias).map(whereAnyStatement => this.whereStatementToExpressionWrapper(eb, whereAnyStatement)))),
+            ]));
+        }
+        return kyselyQuery;
+    }
+    checkForQueryViolations() {
+        const invalidWhereNotClauses = this.similarityStatementBuilder().whereNotStatementsWithSimilarityClauses();
+        if (invalidWhereNotClauses.length) {
+            const { tableName, columnName, opsStatement } = invalidWhereNotClauses[0];
+            throw new CannotNegateSimilarityClause(tableName, columnName, opsStatement.value);
+        }
+    }
+    aliasWhereStatements(whereStatements, alias) {
+        return whereStatements.map(whereStatement => this.aliasWhereStatement(whereStatement, alias));
+    }
+    aliasWhereStatement(whereStatement, alias) {
+        return Object.keys(whereStatement).reduce((aliasedWhere, key) => {
+            aliasedWhere[this.namespaceColumn(key, alias)] = whereStatement[key];
+            return aliasedWhere;
+        }, {});
+    }
+    rawifiedSelfOnClause({ associationAlias, selfAlias, selfOnClause, }) {
+        const alphanumericUnderscoreRegexp = /[^a-zA-Z0-9_]/g;
+        selfAlias = selfAlias.replace(alphanumericUnderscoreRegexp, '');
+        return Object.keys(selfOnClause).reduce((acc, key) => {
+            const selfColumn = selfOnClause[key]?.replace(alphanumericUnderscoreRegexp, '');
+            if (!selfColumn)
+                return acc;
+            acc[this.namespaceColumn(key, associationAlias)] = sql.raw(`"${snakeify(selfAlias)}"."${snakeify(selfColumn)}"`);
+            return acc;
+        }, {});
+    }
+    buildDelete() {
+        const kyselyQuery = this.dbFor('delete').deleteFrom(this.baseSqlAlias);
+        const results = this.attachLimitAndOrderStatementsToNonSelectQuery(kyselyQuery);
+        return results.clone.buildCommon(results.kyselyQuery);
+    }
+    buildSelect({ bypassSelectAll = false, bypassOrder = false, columns, } = {}) {
+        let kyselyQuery;
+        if (this.baseSelectQuery) {
+            kyselyQuery = (this.connectionOverride
+                ? this.baseSelectQuery.connection(this.connectionOverride)
+                : this.baseSelectQuery).buildSelect({ bypassSelectAll: true });
+        }
+        else {
+            const from = this.baseSqlAlias === this.tableName ? this.tableName : `${this.tableName} as ${this.baseSqlAlias}`;
+            kyselyQuery = this.dbFor('select').selectFrom(from);
+        }
+        if (this.distinctColumn) {
+            kyselyQuery = kyselyQuery.distinctOn(this.distinctColumn);
+        }
+        kyselyQuery = this.buildCommon(kyselyQuery);
+        kyselyQuery = this.conditionallyAttachSimilarityColumnsToSelect(kyselyQuery, {
+            bypassOrder: bypassOrder || !!this.distinctColumn,
+        });
+        if (this.orderStatements.length && !bypassOrder) {
+            this.orderStatements.forEach(orderStatement => {
+                kyselyQuery = kyselyQuery.orderBy(this.namespaceColumn(orderStatement.column), orderByDirection(orderStatement.direction));
+            });
+        }
+        if (this.limitStatement)
+            kyselyQuery = kyselyQuery.limit(this.limitStatement);
+        if (this.offsetStatement)
+            kyselyQuery = kyselyQuery.offset(this.offsetStatement);
+        if (columns) {
+            kyselyQuery = kyselyQuery.select(this.columnsWithRequiredLoadColumns(columns).map(column => this.namespaceColumn(column)));
+        }
+        else if (!bypassSelectAll) {
+            kyselyQuery = kyselyQuery.selectAll(this.baseSqlAlias);
+        }
+        return kyselyQuery;
+    }
+    columnsWithRequiredLoadColumns(columns) {
+        return uniq(compact([this.dreamClass.primaryKey, this.dreamClass['isSTIBase'] ? 'type' : null, ...columns]));
+    }
+    buildUpdate(attributes) {
+        let kyselyQuery = this.dbFor('update')
+            .updateTable(this.tableName)
+            .set(attributes);
+        kyselyQuery = this.conditionallyAttachSimilarityColumnsToUpdate(kyselyQuery);
+        const results = this.attachLimitAndOrderStatementsToNonSelectQuery(kyselyQuery);
+        return results.clone.buildCommon(results.kyselyQuery);
+    }
+    attachLimitAndOrderStatementsToNonSelectQuery(kyselyQuery) {
+        if (this.limitStatement || this.orderStatements.length) {
+            kyselyQuery = kyselyQuery.where((eb) => {
+                const subquery = this.nestedSelect(this.dreamInstance.primaryKey);
+                return eb(this.dreamInstance.primaryKey, 'in', subquery);
+            });
+            return {
+                kyselyQuery,
+                clone: this.clone({ where: null, whereNot: null, order: null, limit: null }),
+            };
+        }
+        return { kyselyQuery, clone: this };
+    }
+    get hasSimilarityClauses() {
+        return this.similarityStatementBuilder().hasSimilarityClauses;
+    }
+    similarityStatementBuilder() {
+        return new SimilarityBuilder(this.dreamInstance, {
+            where: [...this.whereStatements],
+            whereNot: [...this.whereNotStatements],
+            joinOnStatements: this.innerJoinOnStatements,
+            transaction: this.dreamTransaction,
+            connection: this.connectionOverride,
+        });
+    }
+    conditionallyAttachSimilarityColumnsToSelect(kyselyQuery, { bypassOrder = false } = {}) {
+        const similarityBuilder = this.similarityStatementBuilder();
+        if (similarityBuilder.hasSimilarityClauses) {
+            kyselyQuery = similarityBuilder.select(kyselyQuery, { bypassOrder });
+        }
+        return kyselyQuery;
+    }
+    conditionallyAttachSimilarityColumnsToUpdate(kyselyQuery) {
+        const similarityBuilder = this.similarityStatementBuilder();
+        if (similarityBuilder.hasSimilarityClauses) {
+            kyselyQuery = similarityBuilder.update(kyselyQuery);
+        }
+        return kyselyQuery;
+    }
+    invertOrder() {
+        let query = this.clone({ order: null });
+        for (const orderStatement of this.orderStatements) {
+            query = query.order({
+                [orderStatement.column]: orderStatement.direction === 'desc' ? 'asc' : 'desc',
+            });
+        }
+        return query;
+    }
+}
+function getSourceAssociation(dream, sourceName) {
+    if (!dream)
+        return;
+    if (!sourceName)
+        return;
+    return (dream['getAssociationMetadata'](sourceName) ||
+        dream['getAssociationMetadata'](pluralize.singular(sourceName)));
+}