velocious 1.0.107 → 1.0.109

package/dist/src/database/query/join-object.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @typedef {{[key: string]: boolean | JoinObject}} JoinObject
+ */
+export default class VelociousDatabaseQueryJoinObject extends JoinBase {
+    /**
+     * @param {JoinObject} object
+     */
+    constructor(object: JoinObject);
+    object: JoinObject;
+    toSql(): string;
+    /**
+     * @param {JoinObject} join
+     * @param {typeof import("../record/index.js").default} modelClass
+     * @param {string} sql
+     * @param {number} joinsCount
+     * @returns {string}
+     */
+    joinObject(join: JoinObject, modelClass: typeof import("../record/index.js").default, sql: string, joinsCount: number): string;
+}
+export type JoinObject = {
+    [key: string]: boolean | JoinObject;
+};
+import JoinBase from "./join-base.js";
+//# sourceMappingURL=join-object.d.ts.map

package/dist/src/database/query/join-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"join-object.d.ts","sourceRoot":"","sources":["../../../../src/database/query/join-object.js"],"names":[],"mappings":"AAIA;;GAEG;AAEH;IACE;;OAEG;IACH,oBAFW,UAAU,EAKpB;IADC,mBAAoB;IAGtB,gBAIC;IAED;;;;;;OAMG;IACH,iBANW,UAAU,cACV,cAAc,oBAAoB,EAAE,OAAO,OAC3C,MAAM,cACN,MAAM,GACJ,MAAM,CAqClB;CACF;yBA7DY;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,GAAG,UAAU,CAAA;CAAC;qBAH7B,gBAAgB"}

package/dist/src/database/query/join-object.js

@@ -0,0 +1,58 @@
+// @ts-check
+import JoinBase from "./join-base.js";
+/**
+ * @typedef {{[key: string]: boolean | JoinObject}} JoinObject
+ */
+export default class VelociousDatabaseQueryJoinObject extends JoinBase {
+    /**
+     * @param {JoinObject} object
+     */
+    constructor(object) {
+        super();
+        this.object = object;
+    }
+    toSql() {
+        const modelClass = this.getQuery().modelClass;
+        return this.joinObject(this.object, modelClass, "", 0);
+    }
+    /**
+     * @param {JoinObject} join
+     * @param {typeof import("../record/index.js").default} modelClass
+     * @param {string} sql
+     * @param {number} joinsCount
+     * @returns {string}
+     */
+    joinObject(join, modelClass, sql, joinsCount) {
+        const pretty = this.pretty;
+        const conn = this.getQuery().driver;
+        for (const joinKey in join) {
+            const joinValue = join[joinKey];
+            const relationship = modelClass.getRelationshipByName(joinKey);
+            const targetModelClass = relationship.getTargetModelClass();
+            if (joinsCount > 0) {
+                if (pretty) {
+                    sql += "\n\n";
+                }
+                else {
+                    sql += " ";
+                }
+            }
+            sql += `LEFT JOIN ${conn.quoteTable(targetModelClass.tableName())} ON `;
+            if (relationship.getType() == "belongsTo") {
+                sql += `${conn.quoteTable(targetModelClass.tableName())}.${conn.quoteColumn(relationship.getPrimaryKey())} = `;
+                sql += `${conn.quoteTable(modelClass.tableName())}.${conn.quoteColumn(relationship.getForeignKey())}`;
+            }
+            else if (relationship.getType() == "hasMany" || relationship.getType() == "hasOne") {
+                sql += `${conn.quoteTable(targetModelClass.tableName())}.${conn.quoteColumn(relationship.getForeignKey())} = `;
+                sql += `${conn.quoteTable(modelClass.tableName())}.${conn.quoteColumn(relationship.getPrimaryKey())}`;
+            }
+            else {
+                throw new Error(`Unknown relationship type: ${relationship.getType()}`);
+            }
+            if (typeof joinValue == "object") {
+                sql = this.joinObject(joinValue, targetModelClass, sql, joinsCount + 1);
+            }
+        }
+        return sql;
+    }
+}

package/dist/src/database/query/join-plain.d.ts

@@ -0,0 +1,10 @@
+export default class VelociousDatabaseQueryJoinPlain extends JoinBase {
+    /**
+     * @param {string} plain
+     */
+    constructor(plain: string);
+    plain: string;
+    toSql(): string;
+}
+import JoinBase from "./join-base.js";
+//# sourceMappingURL=join-plain.d.ts.map

package/dist/src/database/query/join-plain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"join-plain.d.ts","sourceRoot":"","sources":["../../../../src/database/query/join-plain.js"],"names":[],"mappings":"AAIA;IACE;;OAEG;IACH,mBAFW,MAAM,EAKhB;IADC,cAAkB;IAGpB,gBAEC;CACF;qBAdoB,gBAAgB"}

package/dist/src/database/query/join-plain.js

@@ -0,0 +1,14 @@
+// @ts-check
+import JoinBase from "./join-base.js";
+export default class VelociousDatabaseQueryJoinPlain extends JoinBase {
+    /**
+     * @param {string} plain
+     */
+    constructor(plain) {
+        super();
+        this.plain = plain;
+    }
+    toSql() {
+        return this.plain;
+    }
+}

package/dist/src/database/query/order-base.d.ts

@@ -0,0 +1,19 @@
+export default class VelociousDatabaseQueryOrderBase {
+    /**
+     * @param {import("./index.js").default} query
+     */
+    constructor(query: import("./index.js").default);
+    query: import("./index.js").default;
+    /**
+     * @returns {import("../query-parser/options.js").default}
+     */
+    getOptions(): import("../query-parser/options.js").default;
+    /**
+     * @abstract
+     * @param {boolean} _reverseOrder
+     * @returns {void}
+     */
+    setReverseOrder(_reverseOrder: boolean): void;
+    toSql(): void;
+}
+//# sourceMappingURL=order-base.d.ts.map

package/dist/src/database/query/order-base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"order-base.d.ts","sourceRoot":"","sources":["../../../../src/database/query/order-base.js"],"names":[],"mappings":"AAEA;IACE;;OAEG;IACH,mBAFW,OAAO,YAAY,EAAE,OAAO,EAItC;IADC,oCAAkB;IAGpB;;OAEG;IACH,cAFa,OAAO,4BAA4B,EAAE,OAAO,CAIxD;IAED;;;;OAIG;IACH,+BAHW,OAAO,GACL,IAAI,CAIhB;IAED,cAEC;CACF"}

package/dist/src/database/query/order-base.js

@@ -0,0 +1,26 @@
+// @ts-check
+export default class VelociousDatabaseQueryOrderBase {
+    /**
+     * @param {import("./index.js").default} query
+     */
+    constructor(query) {
+        this.query = query;
+    }
+    /**
+     * @returns {import("../query-parser/options.js").default}
+     */
+    getOptions() {
+        return this.query.driver.options();
+    }
+    /**
+     * @abstract
+     * @param {boolean} _reverseOrder
+     * @returns {void}
+     */
+    setReverseOrder(_reverseOrder) {
+        throw new Error("setReverseOrder not implemented");
+    }
+    toSql() {
+        throw new Error("'toSql' wasn't implemented");
+    }
+}

package/dist/src/database/query/order-plain.d.ts

@@ -0,0 +1,13 @@
+export default class VelociousDatabaseQueryOrderPlain extends OrderBase {
+    /**
+     * @param {import("./index.js").default} query
+     * @param {string} plain
+     */
+    constructor(query: import("./index.js").default, plain: string);
+    plain: string;
+    reverseOrder: boolean;
+    setReverseOrder(): void;
+    toSql(): string;
+}
+import OrderBase from "./order-base.js";
+//# sourceMappingURL=order-plain.d.ts.map

package/dist/src/database/query/order-plain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"order-plain.d.ts","sourceRoot":"","sources":["../../../../src/database/query/order-plain.js"],"names":[],"mappings":"AAIA;IACE;;;OAGG;IACH,mBAHW,OAAO,YAAY,EAAE,OAAO,SAC5B,MAAM,EAMhB;IAFC,cAAkB;IAClB,sBAAyB;IAG3B,wBAEC;IAED,gBAMC;CACF;sBAxBqB,iBAAiB"}

package/dist/src/database/query/order-plain.js

@@ -0,0 +1,22 @@
+// @ts-check
+import OrderBase from "./order-base.js";
+export default class VelociousDatabaseQueryOrderPlain extends OrderBase {
+    /**
+     * @param {import("./index.js").default} query
+     * @param {string} plain
+     */
+    constructor(query, plain) {
+        super(query);
+        this.plain = plain;
+        this.reverseOrder = false;
+    }
+    setReverseOrder() {
+        this.reverseOrder = true;
+    }
+    toSql() {
+        if (this.reverseOrder) {
+            return `${this.plain} DESC`;
+        }
+        return this.plain;
+    }
+}

package/dist/src/database/query/preloader/belongs-to.d.ts

@@ -0,0 +1,15 @@
+export default class VelociousDatabaseQueryPreloaderBelongsTo {
+    /**
+     * @param {object} args
+     * @param {import("../../record/index.js").default[]} args.models
+     * @param {import("../../record/relationships/belongs-to.js").default} args.relationship
+     */
+    constructor({ models, relationship, ...restArgs }: {
+        models: import("../../record/index.js").default[];
+        relationship: import("../../record/relationships/belongs-to.js").default;
+    });
+    models: import("../../record/index.js").default[];
+    relationship: import("../../record/relationships/belongs-to.js").default;
+    run(): Promise<import("../../record/index.js").default[]>;
+}
+//# sourceMappingURL=belongs-to.d.ts.map

package/dist/src/database/query/preloader/belongs-to.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"belongs-to.d.ts","sourceRoot":"","sources":["../../../../../src/database/query/preloader/belongs-to.js"],"names":[],"mappings":"AAIA;IACE;;;;OAIG;IACH,mDAHG;QAAwD,MAAM,EAAtD,OAAO,uBAAuB,EAAE,OAAO,EAAE;QACwB,YAAY,EAA7E,OAAO,0CAA0C,EAAE,OAAO;KACpE,EAMA;IAFC,kDAAoB;IACpB,yEAAgC;IAGlC,0DA4CC;CACF"}

package/dist/src/database/query/preloader/belongs-to.js

@@ -0,0 +1,48 @@
+// @ts-check
+import restArgsError from "../../../utils/rest-args-error.js";
+export default class VelociousDatabaseQueryPreloaderBelongsTo {
+    /**
+     * @param {object} args
+     * @param {import("../../record/index.js").default[]} args.models
+     * @param {import("../../record/relationships/belongs-to.js").default} args.relationship
+     */
+    constructor({ models, relationship, ...restArgs }) {
+        restArgsError(restArgs);
+        this.models = models;
+        this.relationship = relationship;
+    }
+    async run() {
+        /** @type {Array<number | string>} */
+        const foreignKeyValues = [];
+        const foreignKey = this.relationship.getForeignKey();
+        for (const model of this.models) {
+            const foreignKeyValue = model.readColumn(foreignKey);
+            if (!foreignKeyValues.includes(foreignKeyValue))
+                foreignKeyValues.push(foreignKeyValue);
+        }
+        /** @type {Record<string, any>} */
+        const whereArgs = {};
+        const primaryKey = this.relationship.getPrimaryKey();
+        whereArgs[primaryKey] = foreignKeyValues;
+        const targetModelClass = this.relationship.getTargetModelClass();
+        if (!targetModelClass)
+            throw new Error("No target model class could be gotten from relationship");
+        // Load target models to be preloaded on the given models
+        const targetModels = await targetModelClass.where(whereArgs).toArray();
+        /** @type {Record<string, import("../../record/index.js").default>} */
+        const targetModelsById = {};
+        for (const targetModel of targetModels) {
+            const primaryKeyValue = targetModel.readColumn(this.relationship.getPrimaryKey());
+            targetModelsById[primaryKeyValue] = targetModel;
+        }
+        // Set the target preloaded models on the given models
+        for (const model of this.models) {
+            const foreignKeyValue = model.readColumn(foreignKey);
+            const targetModel = targetModelsById[foreignKeyValue];
+            const modelRelationship = model.getRelationshipByName(this.relationship.getRelationshipName());
+            modelRelationship.setPreloaded(true);
+            modelRelationship.setLoaded(targetModel);
+        }
+        return targetModels;
+    }
+}

package/dist/src/database/query/preloader/has-many.d.ts

@@ -0,0 +1,15 @@
+export default class VelociousDatabaseQueryPreloaderHasMany {
+    /**
+     * @param {object} args
+     * @param {import("../../record/index.js").default[]} args.models
+     * @param {import("../../record/relationships/has-many.js").default} args.relationship
+     */
+    constructor({ models, relationship, ...restArgs }: {
+        models: import("../../record/index.js").default[];
+        relationship: import("../../record/relationships/has-many.js").default;
+    });
+    models: import("../../record/index.js").default[];
+    relationship: import("../../record/relationships/has-many.js").default;
+    run(): Promise<import("../../record/index.js").default[]>;
+}
+//# sourceMappingURL=has-many.d.ts.map

package/dist/src/database/query/preloader/has-many.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-many.d.ts","sourceRoot":"","sources":["../../../../../src/database/query/preloader/has-many.js"],"names":[],"mappings":"AAIA;IACE;;;;OAIG;IACH,mDAHG;QAAwD,MAAM,EAAtD,OAAO,uBAAuB,EAAE,OAAO,EAAE;QACsB,YAAY,EAA3E,OAAO,wCAAwC,EAAE,OAAO;KAClE,EAMA;IAFC,kDAAoB;IACpB,uEAAgC;IAGlC,0DAgEC;CACF"}

package/dist/src/database/query/preloader/has-many.js

@@ -0,0 +1,63 @@
+// @ts-check
+import restArgsError from "../../../utils/rest-args-error.js";
+export default class VelociousDatabaseQueryPreloaderHasMany {
+    /**
+     * @param {object} args
+     * @param {import("../../record/index.js").default[]} args.models
+     * @param {import("../../record/relationships/has-many.js").default} args.relationship
+     */
+    constructor({ models, relationship, ...restArgs }) {
+        restArgsError(restArgs);
+        this.models = models;
+        this.relationship = relationship;
+    }
+    async run() {
+        /** @type {Array<number | string>} */
+        const modelsPrimaryKeyValues = [];
+        /** @type {Record<number | string, Array<import("../../record/index.js").default>>} */
+        const modelsByPrimaryKeyValue = {};
+        const foreignKey = this.relationship.getForeignKey();
+        const primaryKey = this.relationship.getPrimaryKey();
+        /** @type {Record<number | string, Array<import("../../record/index.js").default>>} */
+        const preloadCollections = {};
+        if (!primaryKey) {
+            throw new Error(`${this.relationship.getModelClass().name}#${this.relationship.getRelationshipName()} doesn't have a primary key`);
+        }
+        for (const model of this.models) {
+            const primaryKeyValue = model.readColumn(primaryKey);
+            preloadCollections[primaryKeyValue] = [];
+            if (!modelsPrimaryKeyValues.includes(primaryKeyValue))
+                modelsPrimaryKeyValues.push(primaryKeyValue);
+            if (!(primaryKeyValue in modelsByPrimaryKeyValue))
+                modelsByPrimaryKeyValue[primaryKeyValue] = [];
+            modelsByPrimaryKeyValue[primaryKeyValue].push(model);
+        }
+        /** @type {Record<string, any>} */
+        const whereArgs = {};
+        whereArgs[foreignKey] = modelsPrimaryKeyValues;
+        const targetModelClass = this.relationship.getTargetModelClass();
+        if (!targetModelClass)
+            throw new Error("No target model class could be gotten from relationship");
+        // Load target models to be preloaded on the given models
+        const targetModels = await targetModelClass.where(whereArgs).toArray();
+        for (const targetModel of targetModels) {
+            const foreignKeyValue = targetModel.readColumn(foreignKey);
+            preloadCollections[foreignKeyValue].push(targetModel);
+        }
+        // Set the target preloaded models on the given models
+        for (const modelValue in preloadCollections) {
+            const preloadedCollection = preloadCollections[modelValue];
+            for (const model of modelsByPrimaryKeyValue[modelValue]) {
+                const modelRelationship = model.getRelationshipByName(this.relationship.getRelationshipName());
+                if (preloadedCollection.length == 0) {
+                    modelRelationship.setLoaded([]);
+                }
+                else {
+                    modelRelationship.addToLoaded(preloadedCollection);
+                }
+                modelRelationship.setPreloaded(true);
+            }
+        }
+        return targetModels;
+    }
+}

package/dist/src/database/query/preloader/has-one.d.ts

@@ -0,0 +1,15 @@
+export default class VelociousDatabaseQueryPreloaderHasOne {
+    /**
+     * @param {object} args
+     * @param {Array<import("../../record/index.js").default>} args.models
+     * @param {import("../../record/relationships/has-one.js").default} args.relationship
+     */
+    constructor({ models, relationship, ...restArgs }: {
+        models: Array<import("../../record/index.js").default>;
+        relationship: import("../../record/relationships/has-one.js").default;
+    });
+    models: import("../../record/index.js").default[];
+    relationship: import("../../record/relationships/has-one.js").default;
+    run(): Promise<import("../../record/index.js").default[]>;
+}
+//# sourceMappingURL=has-one.d.ts.map

package/dist/src/database/query/preloader/has-one.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-one.d.ts","sourceRoot":"","sources":["../../../../../src/database/query/preloader/has-one.js"],"names":[],"mappings":"AAIA;IACE;;;;OAIG;IACH,mDAHG;QAA6D,MAAM,EAA3D,KAAK,CAAC,OAAO,uBAAuB,EAAE,OAAO,CAAC;QACgB,YAAY,EAA1E,OAAO,uCAAuC,EAAE,OAAO;KACjE,EAMA;IAFC,kDAAoB;IACpB,sEAAgC;IAGlC,0DAuDC;CACF"}

package/dist/src/database/query/preloader/has-one.js

@@ -0,0 +1,55 @@
+// @ts-check
+import restArgsError from "../../../utils/rest-args-error.js";
+export default class VelociousDatabaseQueryPreloaderHasOne {
+    /**
+     * @param {object} args
+     * @param {Array<import("../../record/index.js").default>} args.models
+     * @param {import("../../record/relationships/has-one.js").default} args.relationship
+     */
+    constructor({ models, relationship, ...restArgs }) {
+        restArgsError(restArgs);
+        this.models = models;
+        this.relationship = relationship;
+    }
+    async run() {
+        /** @type {Array<number | string>} */
+        const modelsPrimaryKeyValues = [];
+        /** @type {Record<number | string, Array<import("../../record/index.js").default>>} */
+        const modelsByPrimaryKeyValue = {};
+        const foreignKey = this.relationship.getForeignKey();
+        const primaryKey = this.relationship.getPrimaryKey();
+        /** @type {Record<number | string, import("../../record/index.js").default | undefined>} */
+        const preloadCollections = {};
+        for (const model of this.models) {
+            const primaryKeyValue = model.readColumn(primaryKey);
+            preloadCollections[primaryKeyValue] = undefined;
+            if (!modelsPrimaryKeyValues.includes(primaryKeyValue))
+                modelsPrimaryKeyValues.push(primaryKeyValue);
+            if (!(primaryKeyValue in modelsByPrimaryKeyValue))
+                modelsByPrimaryKeyValue[primaryKeyValue] = [];
+            modelsByPrimaryKeyValue[primaryKeyValue].push(model);
+        }
+        /** @type {Record<string, any>} */
+        const whereArgs = {};
+        whereArgs[foreignKey] = modelsPrimaryKeyValues;
+        const targetModelClass = this.relationship.getTargetModelClass();
+        if (!targetModelClass)
+            throw new Error("No target model class could be gotten from relationship");
+        // Load target models to be preloaded on the given models
+        const targetModels = await targetModelClass.where(whereArgs).toArray();
+        for (const targetModel of targetModels) {
+            const foreignKeyValue = targetModel.readColumn(foreignKey);
+            preloadCollections[foreignKeyValue] = targetModel;
+        }
+        // Set the target preloaded models on the given models
+        for (const modelValue in preloadCollections) {
+            const preloadedModel = preloadCollections[modelValue];
+            for (const model of modelsByPrimaryKeyValue[modelValue]) {
+                const modelRelationship = model.getRelationshipByName(this.relationship.getRelationshipName());
+                modelRelationship.setPreloaded(true);
+                modelRelationship.setLoaded(preloadedModel);
+            }
+        }
+        return targetModels;
+    }
+}

package/dist/src/database/query/preloader.d.ts

@@ -0,0 +1,18 @@
+export default class VelociousDatabaseQueryPreloader {
+    /**
+     * @param {object} args
+     * @param {typeof import("../record/index.js").default} args.modelClass
+     * @param {import("../record/index.js").default[]} args.models
+     * @param {Record<string, any>} args.preload
+     */
+    constructor({ modelClass, models, preload, ...restArgs }: {
+        modelClass: typeof import("../record/index.js").default;
+        models: import("../record/index.js").default[];
+        preload: Record<string, any>;
+    });
+    modelClass: typeof import("../record/index.js").default;
+    models: import("../record/index.js").default[];
+    preload: Record<string, any>;
+    run(): Promise<void>;
+}
+//# sourceMappingURL=preloader.d.ts.map

package/dist/src/database/query/preloader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preloader.d.ts","sourceRoot":"","sources":["../../../../src/database/query/preloader.js"],"names":[],"mappings":"AAOA;IACE;;;;;OAKG;IACH,0DAJG;QAA0D,UAAU,EAA5D,cAAc,oBAAoB,EAAE,OAAO;QACE,MAAM,EAAnD,OAAO,oBAAoB,EAAE,OAAO,EAAE;QACZ,OAAO,EAAjC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;KAC7B,EAOA;IAHC,wDAA4B;IAC5B,+CAAoB;IACpB,6BAAsB;IAGxB,qBAqCC;CACF"}

package/dist/src/database/query/preloader.js

@@ -0,0 +1,52 @@
+// @ts-check
+import BelongsToPreloader from "./preloader/belongs-to.js";
+import HasManyPreloader from "./preloader/has-many.js";
+import HasOnePreloader from "./preloader/has-one.js";
+import restArgsError from "../../utils/rest-args-error.js";
+export default class VelociousDatabaseQueryPreloader {
+    /**
+     * @param {object} args
+     * @param {typeof import("../record/index.js").default} args.modelClass
+     * @param {import("../record/index.js").default[]} args.models
+     * @param {Record<string, any>} args.preload
+     */
+    constructor({ modelClass, models, preload, ...restArgs }) {
+        restArgsError(restArgs);
+        this.modelClass = modelClass;
+        this.models = models;
+        this.preload = preload;
+    }
+    async run() {
+        for (const preloadRelationshipName in this.preload) {
+            const relationship = this.modelClass.getRelationshipByName(preloadRelationshipName);
+            let targetModels;
+            if (relationship.getType() == "belongsTo") {
+                const belongsToRelationship = /** @type {import("../record/relationships/belongs-to.js").default} */ (relationship);
+                const hasManyPreloader = new BelongsToPreloader({ models: this.models, relationship: belongsToRelationship });
+                targetModels = await hasManyPreloader.run();
+            }
+            else if (relationship.getType() == "hasMany") {
+                const hasManyRelationship = /** @type {import("../record/relationships/has-many.js").default} */ (relationship);
+                const hasManyPreloader = new HasManyPreloader({ models: this.models, relationship: hasManyRelationship });
+                targetModels = await hasManyPreloader.run();
+            }
+            else if (relationship.getType() == "hasOne") {
+                const hasOneRelationship = /** @type {import("../record/relationships/has-one.js").default} */ (relationship);
+                const hasOnePreloader = new HasOnePreloader({ models: this.models, relationship: hasOneRelationship });
+                targetModels = await hasOnePreloader.run();
+            }
+            else {
+                throw new Error(`Unknown relationship type: ${relationship.getType()}`);
+            }
+            // Handle any further preloads in the tree
+            const newPreload = this.preload[preloadRelationshipName];
+            if (typeof newPreload == "object" && targetModels.length > 0) {
+                const targetModelClass = relationship.getTargetModelClass();
+                if (!targetModelClass)
+                    throw new Error("No target model class could be gotten from relationship");
+                const preloader = new VelociousDatabaseQueryPreloader({ modelClass: targetModelClass, models: targetModels, preload: newPreload });
+                await preloader.run();
+            }
+        }
+    }
+}

package/dist/src/database/query/select-base.d.ts

@@ -0,0 +1,17 @@
+export default class VelociousDatabaseQuerySelectBase {
+    /**
+     * @returns {import("../query-parser/options.js").default}
+     */
+    getOptions(): import("../query-parser/options.js").default;
+    /**
+     * @param {import("./index.js").default} query
+     */
+    setQuery(query: import("./index.js").default): void;
+    query: import("./index.js").default;
+    /**
+     * @abstract
+     * @returns {string}
+     */
+    toSql(): string;
+}
+//# sourceMappingURL=select-base.d.ts.map

package/dist/src/database/query/select-base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"select-base.d.ts","sourceRoot":"","sources":["../../../../src/database/query/select-base.js"],"names":[],"mappings":"AAEA;IACE;;OAEG;IACH,cAFa,OAAO,4BAA4B,EAAE,OAAO,CAMxD;IAED;;OAEG;IACH,gBAFW,OAAO,YAAY,EAAE,OAAO,QAItC;IADC,oCAAkB;IAGpB;;;OAGG;IACH,SAFa,MAAM,CAIlB;CACF"}

package/dist/src/database/query/select-base.js

@@ -0,0 +1,24 @@
+// @ts-check
+export default class VelociousDatabaseQuerySelectBase {
+    /**
+     * @returns {import("../query-parser/options.js").default}
+     */
+    getOptions() {
+        if (!this.query)
+            throw new Error("'query' hasn't been set");
+        return this.query.driver.options();
+    }
+    /**
+     * @param {import("./index.js").default} query
+     */
+    setQuery(query) {
+        this.query = query;
+    }
+    /**
+     * @abstract
+     * @returns {string}
+     */
+    toSql() {
+        throw new Error("'toSql' wasn't implemented");
+    }
+}

package/dist/src/database/query/select-plain.d.ts

@@ -0,0 +1,9 @@
+export default class VelociousDatabaseQuerySelectPlain extends SelectBase {
+    /**
+     * @param {string} plain
+     */
+    constructor(plain: string);
+    plain: string;
+}
+import SelectBase from "./select-base.js";
+//# sourceMappingURL=select-plain.d.ts.map

package/dist/src/database/query/select-plain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"select-plain.d.ts","sourceRoot":"","sources":["../../../../src/database/query/select-plain.js"],"names":[],"mappings":"AAIA;IACE;;OAEG;IACH,mBAFW,MAAM,EAKhB;IADC,cAAkB;CAMrB;uBAdsB,kBAAkB"}

package/dist/src/database/query/select-plain.js

@@ -0,0 +1,14 @@
+// @ts-check
+import SelectBase from "./select-base.js";
+export default class VelociousDatabaseQuerySelectPlain extends SelectBase {
+    /**
+     * @param {string} plain
+     */
+    constructor(plain) {
+        super();
+        this.plain = plain;
+    }
+    toSql() {
+        return this.plain;
+    }
+}

package/dist/src/database/query/select-table-and-column.d.ts

@@ -0,0 +1,13 @@
+export default class VelociousDatabaseQuerySelectTableAndColumn extends SelectBase {
+    /**
+     * @param {string} tableName
+     * @param {string} columnName
+     */
+    constructor(tableName: string, columnName: string);
+    columnName: string;
+    tableName: string;
+    getColumnName(): string;
+    getTableName(): string;
+}
+import SelectBase from "./select-base.js";
+//# sourceMappingURL=select-table-and-column.d.ts.map

package/dist/src/database/query/select-table-and-column.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"select-table-and-column.d.ts","sourceRoot":"","sources":["../../../../src/database/query/select-table-and-column.js"],"names":[],"mappings":"AAIA;IACE;;;OAGG;IACH,uBAHW,MAAM,cACN,MAAM,EAMhB;IAFC,mBAA4B;IAC5B,kBAA0B;IAG5B,wBAEC;IAED,uBAEC;CAKF;uBAxBsB,kBAAkB"}

package/dist/src/database/query/select-table-and-column.js

@@ -0,0 +1,22 @@
+// @ts-check
+import SelectBase from "./select-base.js";
+export default class VelociousDatabaseQuerySelectTableAndColumn extends SelectBase {
+    /**
+     * @param {string} tableName
+     * @param {string} columnName
+     */
+    constructor(tableName, columnName) {
+        super();
+        this.columnName = columnName;
+        this.tableName = tableName;
+    }
+    getColumnName() {
+        return this.columnName;
+    }
+    getTableName() {
+        return this.tableName;
+    }
+    toSql() {
+        return `${this.getOptions().quoteTableName(this.tableName)}.${this.getOptions().quoteColumnName(this.columnName)}`;
+    }
+}