taon-typeorm 19.0.21 → 19.0.22

package/client/lib/typeorm/query-builder/QueryExpressionMap.d.ts

@@ -1,306 +0,0 @@
-// @ts-nocheck
-import { Alias } from "./Alias";
-import { ObjectLiteral } from "../common/ObjectLiteral";
-import { OrderByCondition } from "../find-options/OrderByCondition";
-import { JoinAttribute } from "./JoinAttribute";
-import { QueryBuilder } from "./QueryBuilder";
-import { QueryBuilderCteOptions } from "./QueryBuilderCte";
-import { RelationIdAttribute } from "./relation-id/RelationIdAttribute";
-import { RelationCountAttribute } from "./relation-count/RelationCountAttribute";
-import { DataSource } from "../data-source/DataSource";
-import { EntityMetadata } from "../metadata/EntityMetadata";
-import { SelectQuery } from "./SelectQuery";
-import { ColumnMetadata } from "../metadata/ColumnMetadata";
-import { RelationMetadata } from "../metadata/RelationMetadata";
-import { SelectQueryBuilderOption } from "./SelectQueryBuilderOption";
-import { WhereClause } from "./WhereClause";
-/**
- * Contains all properties of the QueryBuilder that needs to be build a final query.
- */
-export declare class QueryExpressionMap {
-    protected connection: DataSource;
-    /**
-     * Strategy to load relations.
-     */
-    relationLoadStrategy: "join" | "query";
-    /**
-     * Indicates if QueryBuilder used to select entities and not a raw results.
-     */
-    queryEntity: boolean;
-    /**
-     * Main alias is a main selection object selected by QueryBuilder.
-     */
-    mainAlias?: Alias;
-    /**
-     * All aliases (including main alias) used in the query.
-     */
-    aliases: Alias[];
-    /**
-     * Represents query type. QueryBuilder is able to build SELECT, UPDATE and DELETE queries.
-     */
-    queryType: "select" | "update" | "delete" | "insert" | "relation" | "soft-delete" | "restore";
-    /**
-     * Data needs to be SELECT-ed.
-     */
-    selects: SelectQuery[];
-    /**
-     * Max execution time in millisecond.
-     */
-    maxExecutionTime: number;
-    /**
-     * Whether SELECT is DISTINCT.
-     */
-    selectDistinct: boolean;
-    /**
-     * SELECT DISTINCT ON query (postgres).
-     */
-    selectDistinctOn: string[];
-    /**
-     * FROM-s to be selected.
-     */
-    /**
-     * If update query was used, it needs "update set" - properties which will be updated by this query.
-     * If insert query was used, it needs "insert set" - values that needs to be inserted.
-     */
-    valuesSet?: ObjectLiteral | ObjectLiteral[];
-    /**
-     * Optional returning (or output) clause for insert, update or delete queries.
-     */
-    returning: string | string[];
-    /**
-     * Extra returning columns to be added to the returning statement if driver supports it.
-     */
-    extraReturningColumns: ColumnMetadata[];
-    /**
-     * Optional on conflict statement used in insertion query in postgres.
-     */
-    onConflict: string;
-    /**
-     * Optional on ignore statement used in insertion query in databases.
-     */
-    onIgnore: boolean;
-    /**
-     * Optional on update statement used in insertion query in databases.
-     */
-    onUpdate: {
-        conflict?: string | string[];
-        columns?: string[];
-        overwrite?: string[];
-        skipUpdateIfNoValuesChanged?: boolean;
-    };
-    /**
-     * JOIN queries.
-     */
-    joinAttributes: JoinAttribute[];
-    /**
-     * RelationId queries.
-     */
-    relationIdAttributes: RelationIdAttribute[];
-    /**
-     * Relation count queries.
-     */
-    relationCountAttributes: RelationCountAttribute[];
-    /**
-     * WHERE queries.
-     */
-    wheres: WhereClause[];
-    /**
-     * HAVING queries.
-     */
-    havings: {
-        type: "simple" | "and" | "or";
-        condition: string;
-    }[];
-    /**
-     * ORDER BY queries.
-     */
-    orderBys: OrderByCondition;
-    /**
-     * GROUP BY queries.
-     */
-    groupBys: string[];
-    /**
-     * LIMIT query.
-     */
-    limit?: number;
-    /**
-     * OFFSET query.
-     */
-    offset?: number;
-    /**
-     * Number of rows to skip of result using pagination.
-     */
-    skip?: number;
-    /**
-     * Number of rows to take using pagination.
-     */
-    take?: number;
-    /**
-     * Use certain index for the query.
-     *
-     * SELECT * FROM table_name USE INDEX (col1_index, col2_index) WHERE col1=1 AND col2=2 AND col3=3;
-     */
-    useIndex?: string;
-    /**
-     * Locking mode.
-     */
-    lockMode?: "optimistic" | "pessimistic_read" | "pessimistic_write" | "dirty_read" | "pessimistic_partial_write" | "pessimistic_write_or_fail" | "for_no_key_update" | "for_key_share";
-    /**
-     * Current version of the entity, used for locking.
-     */
-    lockVersion?: number | Date;
-    /**
-     * Tables to be specified in the "FOR UPDATE OF" clause, referred by their alias
-     */
-    lockTables?: string[];
-    /**
-     * Modify behavior when encountering locked rows. NOWAIT or SKIP LOCKED
-     */
-    onLocked?: "nowait" | "skip_locked";
-    /**
-     * Indicates if soft-deleted rows should be included in entity result.
-     * By default the soft-deleted rows are not included.
-     */
-    withDeleted: boolean;
-    /**
-     * Parameters used to be escaped in final query.
-     */
-    parameters: ObjectLiteral;
-    /**
-     * Indicates if alias, table names and column names will be escaped by driver, or not.
-     *
-     * todo: rename to isQuotingDisabled, also think if it should be named "escaping"
-     */
-    disableEscaping: boolean;
-    /**
-     * Indicates if virtual columns should be included in entity result.
-     *
-     * todo: what to do with it? is it properly used? what about persistence?
-     */
-    enableRelationIdValues: boolean;
-    /**
-     * Extra where condition appended to the end of original where conditions with AND keyword.
-     * Original condition will be wrapped into brackets.
-     */
-    extraAppendedAndWhereCondition: string;
-    /**
-     * Indicates if query builder creates a subquery.
-     */
-    subQuery: boolean;
-    /**
-     * Indicates if property names are prefixed with alias names during property replacement.
-     * By default this is enabled, however we need this because aliases are not supported in UPDATE and DELETE queries,
-     * but user can use them in WHERE expressions.
-     */
-    aliasNamePrefixingEnabled: boolean;
-    /**
-     * Indicates if query result cache is enabled or not.
-     */
-    cache: boolean;
-    /**
-     * Time in milliseconds in which cache will expire.
-     * If not set then global caching time will be used.
-     */
-    cacheDuration: number;
-    /**
-     * Cache id.
-     * Used to identifier your cache queries.
-     */
-    cacheId: string;
-    /**
-     * Options that define QueryBuilder behaviour.
-     */
-    options: SelectQueryBuilderOption[];
-    /**
-     * Property path of relation to work with.
-     * Used in relational query builder.
-     */
-    relationPropertyPath: string;
-    /**
-     * Entity (target) which relations will be updated.
-     */
-    of: any | any[];
-    /**
-     * List of columns where data should be inserted.
-     * Used in INSERT query.
-     */
-    insertColumns: string[];
-    /**
-     * Used if user wants to update or delete a specific entities.
-     */
-    whereEntities: ObjectLiteral[];
-    /**
-     * Indicates if entity must be updated after insertion / updation.
-     * This may produce extra query or use RETURNING / OUTPUT statement (depend on database).
-     */
-    updateEntity: boolean;
-    /**
-     * Indicates if listeners and subscribers must be called before and after query execution.
-     */
-    callListeners: boolean;
-    /**
-     * Indicates if query must be wrapped into transaction.
-     */
-    useTransaction: boolean;
-    /**
-     * Extra parameters.
-     *
-     * @deprecated Use standard parameters instead
-     */
-    nativeParameters: ObjectLiteral;
-    /**
-     * Query Comment to include extra information for debugging or other purposes.
-     */
-    comment?: string;
-    /**
-     * Items from an entity that have been locally generated & are recorded here for later use.
-     * Examples include the UUID generation when the database does not natively support it.
-     * These are included in the entity index order.
-     */
-    locallyGenerated: {
-        [key: number]: ObjectLiteral;
-    };
-    commonTableExpressions: {
-        queryBuilder: QueryBuilder<any> | string;
-        alias: string;
-        options: QueryBuilderCteOptions;
-    }[];
-    constructor(connection: DataSource);
-    /**
-     * Get all ORDER BY queries - if order by is specified by user then it uses them,
-     * otherwise it uses default entity order by if it was set.
-     */
-    get allOrderBys(): OrderByCondition;
-    /**
-     * Creates a main alias and adds it to the current expression map.
-     */
-    setMainAlias(alias: Alias): Alias;
-    /**
-     * Creates a new alias and adds it to the current expression map.
-     */
-    createAlias(options: {
-        type: "from" | "select" | "join" | "other";
-        name?: string;
-        target?: Function | string;
-        tablePath?: string;
-        subQuery?: string;
-        metadata?: EntityMetadata;
-    }): Alias;
-    /**
-     * Finds alias with the given name.
-     * If alias was not found it throw an exception.
-     */
-    findAliasByName(aliasName: string): Alias;
-    findColumnByAliasExpression(aliasExpression: string): ColumnMetadata | undefined;
-    /**
-     * Gets relation metadata of the relation this query builder works with.
-     *
-     * todo: add proper exceptions
-     */
-    get relationMetadata(): RelationMetadata;
-    /**
-     * Copies all properties of the current QueryExpressionMap into a new one.
-     * Useful when QueryBuilder needs to create a copy of itself.
-     */
-    clone(): QueryExpressionMap;
-}

package/client/lib/typeorm/query-builder/QueryPartialEntity.d.ts

@@ -1,16 +0,0 @@
-// @ts-nocheck
-import { ObjectLiteral } from "../common/ObjectLiteral";
-/**
- * Make all properties in T optional
- */
-export type QueryPartialEntity<T> = {
-    [P in keyof T]?: T[P] | (() => string);
-};
-/**
- * Make all properties in T optional. Deep version.
- */
-export type QueryDeepPartialEntity<T> = _QueryDeepPartialEntity<ObjectLiteral extends T ? unknown : T>;
-type _QueryDeepPartialEntity<T> = {
-    [P in keyof T]?: (T[P] extends Array<infer U> ? Array<_QueryDeepPartialEntity<U>> : T[P] extends ReadonlyArray<infer U> ? ReadonlyArray<_QueryDeepPartialEntity<U>> : _QueryDeepPartialEntity<T[P]>) | (() => string);
-};
-export {};

package/client/lib/typeorm/query-builder/RelationIdLoader.d.ts

@@ -1,71 +0,0 @@
-// @ts-nocheck
-import { RelationMetadata } from "../metadata/RelationMetadata";
-import { DataSource } from "../data-source/DataSource";
-import { ObjectLiteral } from "../common/ObjectLiteral";
-import { SelectQueryBuilder } from "./SelectQueryBuilder";
-/**
- * Loads relation ids for the given entities.
- */
-export declare class RelationIdLoader {
-    private connection;
-    constructor(connection: DataSource);
-    /**
-     * Loads relation ids of the given entity or entities.
-     */
-    load(relation: RelationMetadata, entityOrEntities: ObjectLiteral | ObjectLiteral[], relatedEntityOrRelatedEntities?: ObjectLiteral | ObjectLiteral[]): Promise<any[]>;
-    /**
-     * Loads relation ids of the given entities and groups them into the object with parent and children.
-     *
-     * todo: extract this method?
-     */
-    loadManyToManyRelationIdsAndGroup<E1 extends ObjectLiteral, E2 extends ObjectLiteral>(relation: RelationMetadata, entitiesOrEntities: E1 | E1[], relatedEntityOrEntities?: E2 | E2[], queryBuilder?: SelectQueryBuilder<any>): Promise<{
-        entity: E1;
-        related?: E2 | E2[];
-    }[]>;
-    /**
-     * Loads relation ids of the given entities and maps them into the given entity property.
-     async loadManyToManyRelationIdsAndMap(
-     relation: RelationMetadata,
-     entityOrEntities: ObjectLiteral|ObjectLiteral[],
-     mapToEntityOrEntities: ObjectLiteral|ObjectLiteral[],
-     propertyName: string
-     ): Promise<void> {
-        const relationIds = await this.loadManyToManyRelationIds(relation, entityOrEntities, mapToEntityOrEntities);
-        const mapToEntities = mapToEntityOrEntities instanceof Array ? mapToEntityOrEntities : [mapToEntityOrEntities];
-        const junctionMetadata = relation.junctionEntityMetadata!;
-        const mainAlias = junctionMetadata.name;
-        const columns = relation.isOwning ? junctionMetadata.inverseColumns : junctionMetadata.ownerColumns;
-        const inverseColumns = relation.isOwning ? junctionMetadata.ownerColumns : junctionMetadata.inverseColumns;
-        mapToEntities.forEach(mapToEntity => {
-            mapToEntity[propertyName] = [];
-            relationIds.forEach(relationId => {
-                const match = inverseColumns.every(column => {
-                    return column.referencedColumn!.getEntityValue(mapToEntity) === relationId[mainAlias + "_" + column.propertyName];
-                });
-                if (match) {
-                    if (columns.length === 1) {
-                        mapToEntity[propertyName].push(relationId[mainAlias + "_" + columns[0].propertyName]);
-                    } else {
-                        const value = {};
-                        columns.forEach(column => {
-                            column.referencedColumn!.setEntityValue(value, relationId[mainAlias + "_" + column.propertyName]);
-                        });
-                        mapToEntity[propertyName].push(value);
-                    }
-                }
-            });
-        });
-    }*/
-    /**
-     * Loads relation ids for the many-to-many relation.
-     */
-    protected loadForManyToMany(relation: RelationMetadata, entities: ObjectLiteral[], relatedEntities?: ObjectLiteral[]): Promise<any[]>;
-    /**
-     * Loads relation ids for the many-to-one and one-to-one owner relations.
-     */
-    protected loadForManyToOneAndOneToOneOwner(relation: RelationMetadata, entities: ObjectLiteral[], relatedEntities?: ObjectLiteral[]): Promise<any[]>;
-    /**
-     * Loads relation ids for the one-to-many and one-to-one not owner relations.
-     */
-    protected loadForOneToManyAndOneToOneNotOwner(relation: RelationMetadata, entities: ObjectLiteral[], relatedEntities?: ObjectLiteral[]): Promise<any[]>;
-}

package/client/lib/typeorm/query-builder/RelationLoader.d.ts

@@ -1,60 +0,0 @@
-// @ts-nocheck
-import { DataSource } from "../data-source/DataSource";
-import { ObjectLiteral } from "../common/ObjectLiteral";
-import { QueryRunner } from "../query-runner/QueryRunner";
-import { RelationMetadata } from "../metadata/RelationMetadata";
-import { SelectQueryBuilder } from "./SelectQueryBuilder";
-/**
- * Wraps entities and creates getters/setters for their relations
- * to be able to lazily load relations when accessing these relations.
- */
-export declare class RelationLoader {
-    private connection;
-    constructor(connection: DataSource);
-    /**
-     * Loads relation data for the given entity and its relation.
-     */
-    load(relation: RelationMetadata, entityOrEntities: ObjectLiteral | ObjectLiteral[], queryRunner?: QueryRunner, queryBuilder?: SelectQueryBuilder<any>): Promise<any[]>;
-    /**
-     * Loads data for many-to-one and one-to-one owner relations.
-     *
-     * (ow) post.category<=>category.post
-     * loaded: category from post
-     * example: SELECT category.id AS category_id, category.name AS category_name FROM category category
-     *              INNER JOIN post Post ON Post.category=category.id WHERE Post.id=1
-     */
-    loadManyToOneOrOneToOneOwner(relation: RelationMetadata, entityOrEntities: ObjectLiteral | ObjectLiteral[], queryRunner?: QueryRunner, queryBuilder?: SelectQueryBuilder<any>): Promise<any>;
-    /**
-     * Loads data for one-to-many and one-to-one not owner relations.
-     *
-     * SELECT post
-     * FROM post post
-     * WHERE post.[joinColumn.name] = entity[joinColumn.referencedColumn]
-     */
-    loadOneToManyOrOneToOneNotOwner(relation: RelationMetadata, entityOrEntities: ObjectLiteral | ObjectLiteral[], queryRunner?: QueryRunner, queryBuilder?: SelectQueryBuilder<any>): Promise<any>;
-    /**
-     * Loads data for many-to-many owner relations.
-     *
-     * SELECT category
-     * FROM category category
-     * INNER JOIN post_categories post_categories
-     * ON post_categories.postId = :postId
-     * AND post_categories.categoryId = category.id
-     */
-    loadManyToManyOwner(relation: RelationMetadata, entityOrEntities: ObjectLiteral | ObjectLiteral[], queryRunner?: QueryRunner, queryBuilder?: SelectQueryBuilder<any>): Promise<any>;
-    /**
-     * Loads data for many-to-many not owner relations.
-     *
-     * SELECT post
-     * FROM post post
-     * INNER JOIN post_categories post_categories
-     * ON post_categories.postId = post.id
-     * AND post_categories.categoryId = post_categories.categoryId
-     */
-    loadManyToManyNotOwner(relation: RelationMetadata, entityOrEntities: ObjectLiteral | ObjectLiteral[], queryRunner?: QueryRunner, queryBuilder?: SelectQueryBuilder<any>): Promise<any>;
-    /**
-     * Wraps given entity and creates getters/setters for its given relation
-     * to be able to lazily load data when accessing this relation.
-     */
-    enableLazyLoad(relation: RelationMetadata, entity: ObjectLiteral, queryRunner?: QueryRunner): void;
-}

package/client/lib/typeorm/query-builder/RelationQueryBuilder.d.ts

@@ -1,70 +0,0 @@
-// @ts-nocheck
-import { QueryBuilder } from "./QueryBuilder";
-import { ObjectLiteral } from "../common/ObjectLiteral";
-/**
- * Allows to work with entity relations and perform specific operations with those relations.
- *
- * todo: add transactions everywhere
- */
-export declare class RelationQueryBuilder<Entity extends ObjectLiteral> extends QueryBuilder<Entity> {
-    readonly "@instanceof": symbol;
-    /**
-     * Gets generated SQL query without parameters being replaced.
-     */
-    getQuery(): string;
-    /**
-     * Sets entity (target) which relations will be updated.
-     */
-    of(entity: any | any[]): this;
-    /**
-     * Sets entity relation's value.
-     * Value can be entity, entity id or entity id map (if entity has composite ids).
-     * Works only for many-to-one and one-to-one relations.
-     * For many-to-many and one-to-many relations use #add and #remove methods instead.
-     */
-    set(value: any): Promise<void>;
-    /**
-     * Adds (binds) given value to entity relation.
-     * Value can be entity, entity id or entity id map (if entity has composite ids).
-     * Value also can be array of entities, array of entity ids or array of entity id maps (if entity has composite ids).
-     * Works only for many-to-many and one-to-many relations.
-     * For many-to-one and one-to-one use #set method instead.
-     */
-    add(value: any | any[]): Promise<void>;
-    /**
-     * Removes (unbinds) given value from entity relation.
-     * Value can be entity, entity id or entity id map (if entity has composite ids).
-     * Value also can be array of entities, array of entity ids or array of entity id maps (if entity has composite ids).
-     * Works only for many-to-many and one-to-many relations.
-     * For many-to-one and one-to-one use #set method instead.
-     */
-    remove(value: any | any[]): Promise<void>;
-    /**
-     * Adds (binds) and removes (unbinds) given values to/from entity relation.
-     * Value can be entity, entity id or entity id map (if entity has composite ids).
-     * Value also can be array of entities, array of entity ids or array of entity id maps (if entity has composite ids).
-     * Works only for many-to-many and one-to-many relations.
-     * For many-to-one and one-to-one use #set method instead.
-     */
-    addAndRemove(added: any | any[], removed: any | any[]): Promise<void>;
-    /**
-     * Gets entity's relation id.
-    async getId(): Promise<any> {
-
-    }*/
-    /**
-     * Gets entity's relation ids.
-    async getIds(): Promise<any[]> {
-        return [];
-    }*/
-    /**
-     * Loads a single entity (relational) from the relation.
-     * You can also provide id of relational entity to filter by.
-     */
-    loadOne<T = any>(): Promise<T | undefined>;
-    /**
-     * Loads many entities (relational) from the relation.
-     * You can also provide ids of relational entities to filter by.
-     */
-    loadMany<T = any>(): Promise<T[]>;
-}

package/client/lib/typeorm/query-builder/RelationRemover.d.ts

@@ -1,17 +0,0 @@
-// @ts-nocheck
-import { QueryBuilder } from "./QueryBuilder";
-import { QueryExpressionMap } from "./QueryExpressionMap";
-/**
- * Allows to work with entity relations and perform specific operations with those relations.
- *
- * todo: add transactions everywhere
- */
-export declare class RelationRemover {
-    protected queryBuilder: QueryBuilder<any>;
-    protected expressionMap: QueryExpressionMap;
-    constructor(queryBuilder: QueryBuilder<any>, expressionMap: QueryExpressionMap);
-    /**
-     * Performs remove operation on a relation.
-     */
-    remove(value: any | any[]): Promise<void>;
-}

package/client/lib/typeorm/query-builder/RelationUpdater.d.ts

@@ -1,17 +0,0 @@
-// @ts-nocheck
-import { QueryBuilder } from "./QueryBuilder";
-import { QueryExpressionMap } from "./QueryExpressionMap";
-/**
- * Allows to work with entity relations and perform specific operations with those relations.
- *
- * todo: add transactions everywhere
- */
-export declare class RelationUpdater {
-    protected queryBuilder: QueryBuilder<any>;
-    protected expressionMap: QueryExpressionMap;
-    constructor(queryBuilder: QueryBuilder<any>, expressionMap: QueryExpressionMap);
-    /**
-     * Performs set or add operation on a relation.
-     */
-    update(value: any | any[]): Promise<void>;
-}

package/client/lib/typeorm/query-builder/ReturningResultsEntityUpdator.d.ts

@@ -1,31 +0,0 @@
-// @ts-nocheck
-import { ObjectLiteral } from "../common/ObjectLiteral";
-import { QueryRunner } from "../query-runner/QueryRunner";
-import { QueryExpressionMap } from "./QueryExpressionMap";
-import { ColumnMetadata } from "../metadata/ColumnMetadata";
-import { UpdateResult } from "./result/UpdateResult";
-import { InsertResult } from "./result/InsertResult";
-/**
- * Updates entity with returning results in the entity insert and update operations.
- */
-export declare class ReturningResultsEntityUpdator {
-    protected queryRunner: QueryRunner;
-    protected expressionMap: QueryExpressionMap;
-    constructor(queryRunner: QueryRunner, expressionMap: QueryExpressionMap);
-    /**
-     * Updates entities with a special columns after updation query execution.
-     */
-    update(updateResult: UpdateResult, entities: ObjectLiteral[]): Promise<void>;
-    /**
-     * Updates entities with a special columns after insertion query execution.
-     */
-    insert(insertResult: InsertResult, entities: ObjectLiteral[]): Promise<void>;
-    /**
-     * Columns we need to be returned from the database when we update entity.
-     */
-    getUpdationReturningColumns(): ColumnMetadata[];
-    /**
-     * Columns we need to be returned from the database when we soft delete and restore entity.
-     */
-    getSoftDeletionReturningColumns(): ColumnMetadata[];
-}

package/client/lib/typeorm/query-builder/SelectQuery.d.ts

@@ -1,6 +0,0 @@
-// @ts-nocheck
-export interface SelectQuery {
-    selection: string;
-    aliasName?: string;
-    virtual?: boolean;
-}