taon-typeorm 21.0.12 → 21.0.18

package/lib-prod/typeorm/find-options/FindOptionsUtils.d.ts

@@ -0,0 +1,190 @@
+import { FindManyOptions } from "./FindManyOptions";
+import { FindOneOptions } from "./FindOneOptions";
+import { SelectQueryBuilder } from "../query-builder/SelectQueryBuilder";
+import { EntityMetadata } from "../metadata/EntityMetadata";
+import { FindTreeOptions } from "./FindTreeOptions";
+import { ObjectLiteral } from "../common/ObjectLiteral";
+/**
+ * Utilities to work with FindOptions.
+ */
+export declare class FindOptionsUtils {
+    /**
+     * Checks if given object is really instance of FindOneOptions interface.
+     */
+    static isFindOneOptions<Entity = any>(obj: any): obj is FindOneOptions<Entity>;
+    /**
+     * Checks if given object is really instance of FindManyOptions interface.
+     */
+    static isFindManyOptions<Entity = any>(obj: any): obj is FindManyOptions<Entity>;
+    /**
+     * Checks if given object is really instance of FindOptions interface.
+     */
+    static extractFindManyOptionsAlias(object: any): string | undefined;
+    /**
+     * Applies give find many options to the given query builder.
+
+    static applyFindManyOptionsOrConditionsToQueryBuilder<T>(qb: SelectQueryBuilder<T>, options: FindManyOptions<T>|Partial<T>|undefined): SelectQueryBuilder<T> {
+        if (this.isFindManyOptions(options))
+            return this.applyOptionsToQueryBuilder(qb, options);
+
+        if (options)
+            return qb.where(options);
+
+        return qb;
+    }*/
+    /**
+     * Applies give find options to the given query builder.
+
+    static applyOptionsToQueryBuilder<T>(qb: SelectQueryBuilder<T>, options: FindOneOptions<T>|FindManyOptions<T>|undefined): SelectQueryBuilder<T> {
+
+        // if options are not set then simply return query builder. This is made for simplicity of usage.
+        if (!options || (!this.isFindOneOptions(options) && !this.isFindManyOptions(options)))
+            return qb;
+
+        if (options.transaction === true) {
+            qb.expressionMap.useTransaction = true;
+        }
+
+        if (!qb.expressionMap.mainAlias || !qb.expressionMap.mainAlias.hasMetadata)
+            return qb;
+
+        const metadata = qb.expressionMap.mainAlias!.metadata;
+
+        // apply all options from FindOptions
+        if (options.comment) {
+            qb.comment(options.comment);
+        }
+
+        if (options.withDeleted) {
+            qb.withDeleted();
+        }
+
+        if (options.select) {
+            qb.select([]);
+            options.select.forEach(select => {
+                if (!metadata.hasColumnWithPropertyPath(`${select}`))
+                    throw new TypeORMError(`${select} column was not found in the ${metadata.name} entity.`);
+
+                const columns = metadata.findColumnsWithPropertyPath(`${select}`);
+
+                for (const column of columns) {
+                    qb.addSelect(qb.alias + "." + column.propertyPath);
+                }
+            });
+        }
+
+        if (options.relations) {
+            // Copy because `applyRelationsRecursively` modifies it
+            const allRelations = [...options.relations];
+            this.applyRelationsRecursively(qb, allRelations, qb.expressionMap.mainAlias!.name, qb.expressionMap.mainAlias!.metadata, "");
+            // recursive removes found relations from allRelations array
+            // if there are relations left in this array it means those relations were not found in the entity structure
+            // so, we give an exception about not found relations
+            if (allRelations.length > 0)
+                throw new FindRelationsNotFoundError(allRelations);
+        }
+
+        if (options.join) {
+            if (options.join.leftJoin)
+                Object.keys(options.join.leftJoin).forEach(key => {
+                    qb.leftJoin(options.join!.leftJoin![key], key);
+                });
+
+            if (options.join.innerJoin)
+                Object.keys(options.join.innerJoin).forEach(key => {
+                    qb.innerJoin(options.join!.innerJoin![key], key);
+                });
+
+            if (options.join.leftJoinAndSelect)
+                Object.keys(options.join.leftJoinAndSelect).forEach(key => {
+                    qb.leftJoinAndSelect(options.join!.leftJoinAndSelect![key], key);
+                });
+
+            if (options.join.innerJoinAndSelect)
+                Object.keys(options.join.innerJoinAndSelect).forEach(key => {
+                    qb.innerJoinAndSelect(options.join!.innerJoinAndSelect![key], key);
+                });
+        }
+
+        if (options.cache) {
+            if (options.cache instanceof Object) {
+                const cache = options.cache as { id: any, milliseconds: number };
+                qb.cache(cache.id, cache.milliseconds);
+            } else {
+                qb.cache(options.cache);
+            }
+        }
+
+        if (options.lock) {
+            if (options.lock.mode === "optimistic") {
+                qb.setLock(options.lock.mode, options.lock.version);
+            } else if (
+                options.lock.mode === "pessimistic_read" ||
+                options.lock.mode === "pessimistic_write" ||
+                options.lock.mode === "dirty_read" ||
+                options.lock.mode === "pessimistic_partial_write" ||
+                options.lock.mode === "pessimistic_write_or_fail" ||
+                options.lock.mode === "for_no_key_update" ||
+                options.lock.mode === "for_key_share"
+            ) {
+                const tableNames = options.lock.tables ? options.lock.tables.map((table) => {
+                    const tableAlias = qb.expressionMap.aliases.find((alias) => {
+                        return alias.metadata.tableNameWithoutPrefix === table;
+                    });
+                    if (!tableAlias) {
+                        throw new TypeORMError(`"${table}" is not part of this query`);
+                    }
+                    return qb.escape(tableAlias.name);
+                }) : undefined;
+                qb.setLock(options.lock.mode, undefined, tableNames);
+            }
+        }
+
+        if (options.loadRelationIds === true) {
+            qb.loadAllRelationIds();
+
+        } else if (options.loadRelationIds instanceof Object) {
+            qb.loadAllRelationIds(options.loadRelationIds as any);
+        }
+
+        if (options.where)
+            qb.where(options.where);
+
+        if ((options as FindManyOptions<T>).skip)
+            qb.skip((options as FindManyOptions<T>).skip!);
+
+        if ((options as FindManyOptions<T>).take)
+            qb.take((options as FindManyOptions<T>).take!);
+
+        if (options.order)
+            Object.keys(options.order).forEach(key => {
+                const order = ((options as FindOneOptions<T>).order as any)[key as any];
+
+                if (!metadata.findColumnWithPropertyPath(key))
+                    throw new Error(`${key} column was not found in the ${metadata.name} entity.`);
+
+                switch (order) {
+                    case 1:
+                        qb.addOrderBy(qb.alias + "." + key, "ASC");
+                        break;
+                    case -1:
+                        qb.addOrderBy(qb.alias + "." + key, "DESC");
+                        break;
+                    case "ASC":
+                        qb.addOrderBy(qb.alias + "." + key, "ASC");
+                        break;
+                    case "DESC":
+                        qb.addOrderBy(qb.alias + "." + key, "DESC");
+                        break;
+                }
+            });
+
+        return qb;
+    }*/
+    static applyOptionsToTreeQueryBuilder<T extends ObjectLiteral>(qb: SelectQueryBuilder<T>, options?: FindTreeOptions): SelectQueryBuilder<T>;
+    /**
+     * Adds joins for all relations and sub-relations of the given relations provided in the find options.
+     */
+    static applyRelationsRecursively(qb: SelectQueryBuilder<any>, allRelations: string[], alias: string, metadata: EntityMetadata, prefix: string): void;
+    static joinEagerRelations(qb: SelectQueryBuilder<any>, alias: string, metadata: EntityMetadata): void;
+}

package/lib-prod/typeorm/find-options/FindOptionsUtils.js

@@ -0,0 +1,319 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindOptionsUtils = void 0;
+const FindRelationsNotFoundError_1 = require("../error/FindRelationsNotFoundError");
+const DriverUtils_1 = require("../driver/DriverUtils");
+/**
+ * Utilities to work with FindOptions.
+ */
+class FindOptionsUtils {
+    // -------------------------------------------------------------------------
+    // Public Static Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Checks if given object is really instance of FindOneOptions interface.
+     */
+    static isFindOneOptions(obj) {
+        const possibleOptions = obj;
+        return (possibleOptions &&
+            (Array.isArray(possibleOptions.select) ||
+                Array.isArray(possibleOptions.relations) ||
+                typeof possibleOptions.select === "object" ||
+                typeof possibleOptions.relations === "object" ||
+                typeof possibleOptions.where === "object" ||
+                // typeof possibleOptions.where === "string" ||
+                typeof possibleOptions.join === "object" ||
+                typeof possibleOptions.order === "object" ||
+                typeof possibleOptions.cache === "object" ||
+                typeof possibleOptions.cache === "boolean" ||
+                typeof possibleOptions.cache === "number" ||
+                typeof possibleOptions.comment === "string" ||
+                typeof possibleOptions.lock === "object" ||
+                typeof possibleOptions.loadRelationIds === "object" ||
+                typeof possibleOptions.loadRelationIds === "boolean" ||
+                typeof possibleOptions.loadEagerRelations === "boolean" ||
+                typeof possibleOptions.withDeleted === "boolean" ||
+                typeof possibleOptions.relationLoadStrategy === "string" ||
+                typeof possibleOptions.transaction === "boolean"));
+    }
+    /**
+     * Checks if given object is really instance of FindManyOptions interface.
+     */
+    static isFindManyOptions(obj) {
+        const possibleOptions = obj;
+        return (possibleOptions &&
+            (this.isFindOneOptions(possibleOptions) ||
+                typeof possibleOptions.skip ===
+                    "number" ||
+                typeof possibleOptions.take ===
+                    "number" ||
+                typeof possibleOptions.skip ===
+                    "string" ||
+                typeof possibleOptions.take ===
+                    "string"));
+    }
+    /**
+     * Checks if given object is really instance of FindOptions interface.
+     */
+    static extractFindManyOptionsAlias(object) {
+        if (this.isFindManyOptions(object) && object.join)
+            return object.join.alias;
+        return undefined;
+    }
+    /**
+     * Applies give find many options to the given query builder.
+
+    static applyFindManyOptionsOrConditionsToQueryBuilder<T>(qb: SelectQueryBuilder<T>, options: FindManyOptions<T>|Partial<T>|undefined): SelectQueryBuilder<T> {
+        if (this.isFindManyOptions(options))
+            return this.applyOptionsToQueryBuilder(qb, options);
+
+        if (options)
+            return qb.where(options);
+
+        return qb;
+    }*/
+    /**
+     * Applies give find options to the given query builder.
+
+    static applyOptionsToQueryBuilder<T>(qb: SelectQueryBuilder<T>, options: FindOneOptions<T>|FindManyOptions<T>|undefined): SelectQueryBuilder<T> {
+
+        // if options are not set then simply return query builder. This is made for simplicity of usage.
+        if (!options || (!this.isFindOneOptions(options) && !this.isFindManyOptions(options)))
+            return qb;
+
+        if (options.transaction === true) {
+            qb.expressionMap.useTransaction = true;
+        }
+
+        if (!qb.expressionMap.mainAlias || !qb.expressionMap.mainAlias.hasMetadata)
+            return qb;
+
+        const metadata = qb.expressionMap.mainAlias!.metadata;
+
+        // apply all options from FindOptions
+        if (options.comment) {
+            qb.comment(options.comment);
+        }
+
+        if (options.withDeleted) {
+            qb.withDeleted();
+        }
+
+        if (options.select) {
+            qb.select([]);
+            options.select.forEach(select => {
+                if (!metadata.hasColumnWithPropertyPath(`${select}`))
+                    throw new TypeORMError(`${select} column was not found in the ${metadata.name} entity.`);
+
+                const columns = metadata.findColumnsWithPropertyPath(`${select}`);
+
+                for (const column of columns) {
+                    qb.addSelect(qb.alias + "." + column.propertyPath);
+                }
+            });
+        }
+
+        if (options.relations) {
+            // Copy because `applyRelationsRecursively` modifies it
+            const allRelations = [...options.relations];
+            this.applyRelationsRecursively(qb, allRelations, qb.expressionMap.mainAlias!.name, qb.expressionMap.mainAlias!.metadata, "");
+            // recursive removes found relations from allRelations array
+            // if there are relations left in this array it means those relations were not found in the entity structure
+            // so, we give an exception about not found relations
+            if (allRelations.length > 0)
+                throw new FindRelationsNotFoundError(allRelations);
+        }
+
+        if (options.join) {
+            if (options.join.leftJoin)
+                Object.keys(options.join.leftJoin).forEach(key => {
+                    qb.leftJoin(options.join!.leftJoin![key], key);
+                });
+
+            if (options.join.innerJoin)
+                Object.keys(options.join.innerJoin).forEach(key => {
+                    qb.innerJoin(options.join!.innerJoin![key], key);
+                });
+
+            if (options.join.leftJoinAndSelect)
+                Object.keys(options.join.leftJoinAndSelect).forEach(key => {
+                    qb.leftJoinAndSelect(options.join!.leftJoinAndSelect![key], key);
+                });
+
+            if (options.join.innerJoinAndSelect)
+                Object.keys(options.join.innerJoinAndSelect).forEach(key => {
+                    qb.innerJoinAndSelect(options.join!.innerJoinAndSelect![key], key);
+                });
+        }
+
+        if (options.cache) {
+            if (options.cache instanceof Object) {
+                const cache = options.cache as { id: any, milliseconds: number };
+                qb.cache(cache.id, cache.milliseconds);
+            } else {
+                qb.cache(options.cache);
+            }
+        }
+
+        if (options.lock) {
+            if (options.lock.mode === "optimistic") {
+                qb.setLock(options.lock.mode, options.lock.version);
+            } else if (
+                options.lock.mode === "pessimistic_read" ||
+                options.lock.mode === "pessimistic_write" ||
+                options.lock.mode === "dirty_read" ||
+                options.lock.mode === "pessimistic_partial_write" ||
+                options.lock.mode === "pessimistic_write_or_fail" ||
+                options.lock.mode === "for_no_key_update" ||
+                options.lock.mode === "for_key_share"
+            ) {
+                const tableNames = options.lock.tables ? options.lock.tables.map((table) => {
+                    const tableAlias = qb.expressionMap.aliases.find((alias) => {
+                        return alias.metadata.tableNameWithoutPrefix === table;
+                    });
+                    if (!tableAlias) {
+                        throw new TypeORMError(`"${table}" is not part of this query`);
+                    }
+                    return qb.escape(tableAlias.name);
+                }) : undefined;
+                qb.setLock(options.lock.mode, undefined, tableNames);
+            }
+        }
+
+        if (options.loadRelationIds === true) {
+            qb.loadAllRelationIds();
+
+        } else if (options.loadRelationIds instanceof Object) {
+            qb.loadAllRelationIds(options.loadRelationIds as any);
+        }
+
+        if (options.where)
+            qb.where(options.where);
+
+        if ((options as FindManyOptions<T>).skip)
+            qb.skip((options as FindManyOptions<T>).skip!);
+
+        if ((options as FindManyOptions<T>).take)
+            qb.take((options as FindManyOptions<T>).take!);
+
+        if (options.order)
+            Object.keys(options.order).forEach(key => {
+                const order = ((options as FindOneOptions<T>).order as any)[key as any];
+
+                if (!metadata.findColumnWithPropertyPath(key))
+                    throw new Error(`${key} column was not found in the ${metadata.name} entity.`);
+
+                switch (order) {
+                    case 1:
+                        qb.addOrderBy(qb.alias + "." + key, "ASC");
+                        break;
+                    case -1:
+                        qb.addOrderBy(qb.alias + "." + key, "DESC");
+                        break;
+                    case "ASC":
+                        qb.addOrderBy(qb.alias + "." + key, "ASC");
+                        break;
+                    case "DESC":
+                        qb.addOrderBy(qb.alias + "." + key, "DESC");
+                        break;
+                }
+            });
+
+        return qb;
+    }*/
+    static applyOptionsToTreeQueryBuilder(qb, options) {
+        if (options?.relations) {
+            // Copy because `applyRelationsRecursively` modifies it
+            const allRelations = [...options.relations];
+            FindOptionsUtils.applyRelationsRecursively(qb, allRelations, qb.expressionMap.mainAlias.name, qb.expressionMap.mainAlias.metadata, "");
+            // recursive removes found relations from allRelations array
+            // if there are relations left in this array it means those relations were not found in the entity structure
+            // so, we give an exception about not found relations
+            if (allRelations.length > 0)
+                throw new FindRelationsNotFoundError_1.FindRelationsNotFoundError(allRelations);
+        }
+        return qb;
+    }
+    // -------------------------------------------------------------------------
+    // Protected Static Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Adds joins for all relations and sub-relations of the given relations provided in the find options.
+     */
+    static applyRelationsRecursively(qb, allRelations, alias, metadata, prefix) {
+        // find all relations that match given prefix
+        let matchedBaseRelations = [];
+        if (prefix) {
+            const regexp = new RegExp("^" + prefix.replace(".", "\\.") + "\\.");
+            matchedBaseRelations = allRelations
+                .filter((relation) => relation.match(regexp))
+                .map((relation) => relation.replace(regexp, ""))
+                .filter((relation) => metadata.findRelationWithPropertyPath(relation));
+        }
+        else {
+            matchedBaseRelations = allRelations.filter((relation) => metadata.findRelationWithPropertyPath(relation));
+        }
+        // go through all matched relations and add join for them
+        matchedBaseRelations.forEach((relation) => {
+            // generate a relation alias
+            let relationAlias = DriverUtils_1.DriverUtils.buildAlias(qb.connection.driver, { joiner: "__" }, alias, relation);
+            // add a join for the found relation
+            const selection = alias + "." + relation;
+            qb.leftJoinAndSelect(selection, relationAlias);
+            // remove added relations from the allRelations array, this is needed to find all not found relations at the end
+            allRelations.splice(allRelations.indexOf(prefix ? prefix + "." + relation : relation), 1);
+            // try to find sub-relations
+            const join = qb.expressionMap.joinAttributes.find((join) => join.entityOrProperty === selection);
+            this.applyRelationsRecursively(qb, allRelations, join.alias.name, join.metadata, prefix ? prefix + "." + relation : relation);
+            // join the eager relations of the found relation
+            const relMetadata = metadata.relations.find((metadata) => metadata.propertyName === relation);
+            if (relMetadata) {
+                this.joinEagerRelations(qb, relationAlias, relMetadata.inverseEntityMetadata);
+            }
+        });
+    }
+    static joinEagerRelations(qb, alias, metadata) {
+        metadata.eagerRelations.forEach((relation) => {
+            // generate a relation alias
+            let relationAlias = DriverUtils_1.DriverUtils.buildAlias(qb.connection.driver, qb.connection.namingStrategy.eagerJoinRelationAlias(alias, relation.propertyPath));
+            // add a join for the relation
+            // Checking whether the relation wasn't joined yet.
+            let addJoin = true;
+            for (const join of qb.expressionMap.joinAttributes) {
+                if (join.condition !== undefined ||
+                    join.mapToProperty !== undefined ||
+                    join.isMappingMany !== undefined ||
+                    join.direction !== "LEFT" ||
+                    join.entityOrProperty !==
+                        `${alias}.${relation.propertyPath}`) {
+                    continue;
+                }
+                addJoin = false;
+                relationAlias = join.alias.name;
+                break;
+            }
+            if (addJoin) {
+                qb.leftJoin(alias + "." + relation.propertyPath, relationAlias);
+            }
+            // Checking whether the relation wasn't selected yet.
+            // This check shall be after the join check to detect relationAlias.
+            let addSelect = true;
+            for (const select of qb.expressionMap.selects) {
+                if (select.aliasName !== undefined ||
+                    select.virtual !== undefined ||
+                    select.selection !== relationAlias) {
+                    continue;
+                }
+                addSelect = false;
+                break;
+            }
+            if (addSelect) {
+                qb.addSelect(relationAlias);
+            }
+            // (recursive) join the eager relations
+            this.joinEagerRelations(qb, relationAlias, relation.inverseEntityMetadata);
+        });
+    }
+}
+exports.FindOptionsUtils = FindOptionsUtils;
+//# sourceMappingURL=FindOptionsUtils.js.map

package/lib-prod/typeorm/find-options/FindOptionsUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FindOptionsUtils.js","sourceRoot":"","sources":[""],"names":[],"mappings":"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"}

package/lib-prod/typeorm/find-options/FindOptionsWhere.d.ts

@@ -0,0 +1,13 @@
+import { FindOperator } from "./FindOperator";
+import { ObjectID } from "../driver/mongodb/typings";
+import { EqualOperator } from "./EqualOperator";
+/**
+ * A single property handler for FindOptionsWhere.
+ */
+export type FindOptionsWhereProperty<Property> = Property extends Promise<infer I> ? FindOptionsWhereProperty<NonNullable<I>> : Property extends Array<infer I> ? FindOptionsWhereProperty<NonNullable<I>> : Property extends Function ? never : Property extends Buffer ? Property | FindOperator<Property> : Property extends Date ? Property | FindOperator<Property> : Property extends ObjectID ? Property | FindOperator<Property> : Property extends object ? FindOptionsWhere<Property> | FindOptionsWhere<Property>[] | EqualOperator<Property> | FindOperator<any> | boolean : Property | FindOperator<Property>;
+/** :
+ * Used for find operations.
+ */
+export type FindOptionsWhere<Entity> = {
+    [P in keyof Entity]?: P extends "toString" ? unknown : FindOptionsWhereProperty<NonNullable<Entity[P]>>;
+};

package/lib-prod/typeorm/find-options/FindOptionsWhere.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=FindOptionsWhere.js.map

package/lib-prod/typeorm/find-options/FindOptionsWhere.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FindOptionsWhere.js","sourceRoot":"","sources":[""],"names":[],"mappings":""}

package/lib-prod/typeorm/find-options/FindTreeOptions.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Defines a special criteria to find specific entities.
+ */
+export interface FindTreeOptions {
+    /**
+     * Indicates what relations of entity should be loaded (simplified left join form).
+     */
+    relations?: string[];
+    /**
+     * When loading a tree from a TreeRepository, limits the depth of the descendents loaded
+     */
+    depth?: number;
+}

package/lib-prod/typeorm/find-options/FindTreeOptions.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=FindTreeOptions.js.map

package/lib-prod/typeorm/find-options/FindTreeOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FindTreeOptions.js","sourceRoot":"","sources":[""],"names":[],"mappings":""}

package/lib-prod/typeorm/find-options/JoinOptions.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Used to specify what entity relations should be loaded.
+ *
+ * Example:
+ *  const options: JoinOptions = {
+ *     alias: "photo",
+ *     leftJoin: {
+ *         author: "photo.author",
+ *         categories: "categories",
+ *         user: "categories.user",
+ *         profile: "user.profile"
+ *     },
+ *     innerJoin: {
+ *         author: "photo.author",
+ *         categories: "categories",
+ *         user: "categories.user",
+ *         profile: "user.profile"
+ *     },
+ *     leftJoinAndSelect: {
+ *         author: "photo.author",
+ *         categories: "categories",
+ *         user: "categories.user",
+ *         profile: "user.profile"
+ *     },
+ *     innerJoinAndSelect: {
+ *         author: "photo.author",
+ *         categories: "categories",
+ *         user: "categories.user",
+ *         profile: "user.profile"
+ *     }
+ * };
+ *
+ * @deprecated
+ */
+export interface JoinOptions {
+    /**
+     * Alias of the main entity.
+     */
+    alias: string;
+    /**
+     * Object where each key represents the LEFT JOIN alias,
+     * and the corresponding value represents the relation path.
+     *
+     * The columns of the joined table are included in the selection.
+     */
+    leftJoinAndSelect?: {
+        [key: string]: string;
+    };
+    /**
+     * Object where each key represents the INNER JOIN alias,
+     * and the corresponding value represents the relation path.
+     *
+     * The columns of the joined table are included in the selection.
+     */
+    innerJoinAndSelect?: {
+        [key: string]: string;
+    };
+    /**
+     * Object where each key represents the LEFT JOIN alias,
+     * and the corresponding value represents the relation path.
+     *
+     * This method does not select the columns of the joined table.
+     */
+    leftJoin?: {
+        [key: string]: string;
+    };
+    /**
+     * Object where each key represents the INNER JOIN alias,
+     * and the corresponding value represents the relation path.
+     *
+     * This method does not select the columns of the joined table.
+     */
+    innerJoin?: {
+        [key: string]: string;
+    };
+}

package/lib-prod/typeorm/find-options/JoinOptions.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=JoinOptions.js.map

package/lib-prod/typeorm/find-options/JoinOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"JoinOptions.js","sourceRoot":"","sources":[""],"names":[],"mappings":""}

package/lib-prod/typeorm/find-options/OrderByCondition.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Special object that defines order condition for ORDER BY in sql.
+ *
+ * Example:
+ * {
+ *  "name": "ASC",
+ *  "id": "DESC"
+ * }
+ *
+ * @deprecated
+ */
+export type OrderByCondition = {
+    [columnName: string]: ("ASC" | "DESC") | {
+        order: "ASC" | "DESC";
+        nulls?: "NULLS FIRST" | "NULLS LAST";
+    };
+};

package/lib-prod/typeorm/find-options/OrderByCondition.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=OrderByCondition.js.map