taon-typeorm 19.0.21 → 19.0.22

package/client/lib/typeorm/metadata/IndexMetadata.d.ts

@@ -1,112 +0,0 @@
-// @ts-nocheck
-import { EntityMetadata } from "./EntityMetadata";
-import { IndexMetadataArgs } from "../metadata-args/IndexMetadataArgs";
-import { NamingStrategyInterface } from "../naming-strategy/NamingStrategyInterface";
-import { ColumnMetadata } from "./ColumnMetadata";
-import { EmbeddedMetadata } from "./EmbeddedMetadata";
-/**
- * Index metadata contains all information about table's index.
- */
-export declare class IndexMetadata {
-    /**
-     * Entity metadata of the class to which this index is applied.
-     */
-    entityMetadata: EntityMetadata;
-    /**
-     * Embedded metadata if this index was applied on embedded.
-     */
-    embeddedMetadata?: EmbeddedMetadata;
-    /**
-     * Indicates if this index must be unique.
-     */
-    isUnique: boolean;
-    /**
-     * The SPATIAL modifier indexes the entire column and does not allow indexed columns to contain NULL values.
-     * Works only in MySQL.
-     */
-    isSpatial: boolean;
-    /**
-     * The FULLTEXT modifier indexes the entire column and does not allow prefixing.
-     * Works only in MySQL.
-     */
-    isFulltext: boolean;
-    /**
-     * NULL_FILTERED indexes are particularly useful for indexing sparse columns, where most rows contain a NULL value.
-     * In these cases, the NULL_FILTERED index can be considerably smaller and more efficient to maintain than
-     * a normal index that includes NULL values.
-     *
-     * Works only in Spanner.
-     */
-    isNullFiltered: boolean;
-    /**
-     * Fulltext parser.
-     * Works only in MySQL.
-     */
-    parser?: string;
-    /**
-     * Indicates if this index must synchronize with database index.
-     */
-    synchronize: boolean;
-    /**
-     * If true, the index only references documents with the specified field.
-     * These indexes use less space but behave differently in some situations (particularly sorts).
-     * This option is only supported for mongodb database.
-     */
-    isSparse?: boolean;
-    /**
-     * Builds the index in the background so that building an index an does not block other database activities.
-     * This option is only supported for mongodb database.
-     */
-    isBackground?: boolean;
-    /**
-     * Specifies a time to live, in seconds.
-     * This option is only supported for mongodb database.
-     */
-    expireAfterSeconds?: number;
-    /**
-     * Target class to which metadata is applied.
-     */
-    target?: Function | string;
-    /**
-     * Indexed columns.
-     */
-    columns: ColumnMetadata[];
-    /**
-     * User specified index name.
-     */
-    givenName?: string;
-    /**
-     * User specified column names.
-     */
-    givenColumnNames?: ((object?: any) => any[] | {
-        [key: string]: number;
-    }) | string[];
-    /**
-     * Final index name.
-     * If index name was given by a user then it stores normalized (by naming strategy) givenName.
-     * If index name was not given then its generated.
-     */
-    name: string;
-    /**
-     * Index filter condition.
-     */
-    where?: string;
-    /**
-     * Map of column names with order set.
-     * Used only by MongoDB driver.
-     */
-    columnNamesWithOrderingMap: {
-        [key: string]: number;
-    };
-    constructor(options: {
-        entityMetadata: EntityMetadata;
-        embeddedMetadata?: EmbeddedMetadata;
-        columns?: ColumnMetadata[];
-        args?: IndexMetadataArgs;
-    });
-    /**
-     * Builds some depend index properties.
-     * Must be called after all entity metadata's properties map, columns and relations are built.
-     */
-    build(namingStrategy: NamingStrategyInterface): this;
-}

package/client/lib/typeorm/metadata/RelationCountMetadata.d.ts

@@ -1,47 +0,0 @@
-// @ts-nocheck
-import { RelationCountMetadataArgs } from "../metadata-args/RelationCountMetadataArgs";
-import { EntityMetadata } from "./EntityMetadata";
-import { RelationMetadata } from "./RelationMetadata";
-import { SelectQueryBuilder } from "../query-builder/SelectQueryBuilder";
-/**
- * Contains all information about entity's relation count.
- */
-export declare class RelationCountMetadata {
-    /**
-     * Entity metadata where this column metadata is.
-     */
-    entityMetadata: EntityMetadata;
-    /**
-     * Relation which needs to be counted.
-     */
-    relation: RelationMetadata;
-    /**
-     * Relation name which need to count.
-     */
-    relationNameOrFactory: string | ((object: any) => any);
-    /**
-     * Target class to which metadata is applied.
-     */
-    target: Function | string;
-    /**
-     * Target's property name to which this metadata is applied.
-     */
-    propertyName: string;
-    /**
-     * Alias of the joined (destination) table.
-     */
-    alias?: string;
-    /**
-     * Extra condition applied to "ON" section of join.
-     */
-    queryBuilderFactory?: (qb: SelectQueryBuilder<any>) => SelectQueryBuilder<any>;
-    constructor(options: {
-        entityMetadata: EntityMetadata;
-        args: RelationCountMetadataArgs;
-    });
-    /**
-     * Builds some depend relation count metadata properties.
-     * This builder method should be used only after entity metadata, its properties map and all relations are build.
-     */
-    build(): void;
-}

package/client/lib/typeorm/metadata/RelationIdMetadata.d.ts

@@ -1,54 +0,0 @@
-// @ts-nocheck
-import { RelationIdMetadataArgs } from "../metadata-args/RelationIdMetadataArgs";
-import { EntityMetadata } from "./EntityMetadata";
-import { RelationMetadata } from "./RelationMetadata";
-import { SelectQueryBuilder } from "../query-builder/SelectQueryBuilder";
-import { ObjectLiteral } from "../common/ObjectLiteral";
-/**
- * Contains all information about entity's relation count.
- */
-export declare class RelationIdMetadata {
-    /**
-     * Entity metadata where this column metadata is.
-     */
-    entityMetadata: EntityMetadata;
-    /**
-     * Relation from which ids will be extracted.
-     */
-    relation: RelationMetadata;
-    /**
-     * Relation name which need to count.
-     */
-    relationNameOrFactory: string | ((object: any) => any);
-    /**
-     * Target class to which metadata is applied.
-     */
-    target: Function | string;
-    /**
-     * Target's property name to which this metadata is applied.
-     */
-    propertyName: string;
-    /**
-     * Alias of the joined (destination) table.
-     */
-    alias?: string;
-    /**
-     * Extra condition applied to "ON" section of join.
-     */
-    queryBuilderFactory?: (qb: SelectQueryBuilder<any>) => SelectQueryBuilder<any>;
-    constructor(options: {
-        entityMetadata: EntityMetadata;
-        args: RelationIdMetadataArgs;
-    });
-    /**
-     * Sets relation id value from the given entity.
-     *
-     * todo: make it to work in embeds as well.
-     */
-    setValue(entity: ObjectLiteral): void;
-    /**
-     * Builds some depend relation id properties.
-     * This builder method should be used only after entity metadata, its properties map and all relations are build.
-     */
-    build(): void;
-}

package/client/lib/typeorm/metadata/RelationMetadata.d.ts

@@ -1,291 +0,0 @@
-// @ts-nocheck
-import { RelationType } from "./types/RelationTypes";
-import { EntityMetadata } from "./EntityMetadata";
-import { ForeignKeyMetadata } from "./ForeignKeyMetadata";
-import { ObjectLiteral } from "../common/ObjectLiteral";
-import { ColumnMetadata } from "./ColumnMetadata";
-import { EmbeddedMetadata } from "./EmbeddedMetadata";
-import { RelationMetadataArgs } from "../metadata-args/RelationMetadataArgs";
-import { DeferrableType } from "./types/DeferrableType";
-import { OnUpdateType } from "./types/OnUpdateType";
-import { OnDeleteType } from "./types/OnDeleteType";
-import { PropertyTypeFactory } from "./types/PropertyTypeInFunction";
-/**
- * Contains all information about some entity's relation.
- */
-export declare class RelationMetadata {
-    /**
-     * Entity metadata of the entity where this relation is placed.
-     *
-     * For example for @ManyToMany(type => Category) in Post, entityMetadata will be metadata of Post entity.
-     */
-    entityMetadata: EntityMetadata;
-    /**
-     * Entity metadata of the entity that is targeted by this relation.
-     *
-     * For example for @ManyToMany(type => Category) in Post, inverseEntityMetadata will be metadata of Category entity.
-     */
-    inverseEntityMetadata: EntityMetadata;
-    /**
-     * Entity metadata of the junction table.
-     * Junction tables have their own entity metadata objects.
-     * Defined only for many-to-many relations.
-     */
-    junctionEntityMetadata?: EntityMetadata;
-    /**
-     * Embedded metadata where this relation is.
-     * If this relation is not in embed then this property value is undefined.
-     */
-    embeddedMetadata?: EmbeddedMetadata;
-    /**
-     * Relation type, e.g. is it one-to-one, one-to-many, many-to-one or many-to-many.
-     */
-    relationType: RelationType;
-    /**
-     * Target entity to which this relation is applied.
-     * Target IS NOT equal to entityMetadata.target, because relation
-     *
-     * For example for @ManyToMany(type => Category) in Post, target will be Post.
-     * If @ManyToMany(type => Category) is in Counters which is embedded into Post, target will be Counters.
-     * If @ManyToMany(type => Category) is in abstract class BaseUser which Post extends, target will be BaseUser.
-     * Target can be string if its defined in entity schema instead of class.
-     */
-    target: Function | string;
-    /**
-     * Target's property name to which relation decorator is applied.
-     */
-    propertyName: string;
-    /**
-     * Gets full path to this column property (including relation name).
-     * Full path is relevant when column is used in embeds (one or multiple nested).
-     * For example it will return "counters.subcounters.likes".
-     * If property is not in embeds then it returns just property name of the column.
-     */
-    propertyPath: string;
-    /**
-     * Indicates if this is a parent (can be only many-to-one relation) relation in the tree tables.
-     */
-    isTreeParent: boolean;
-    /**
-     * Indicates if this is a children (can be only one-to-many relation) relation in the tree tables.
-     */
-    isTreeChildren: boolean;
-    /**
-     * Indicates if this relation's column is a primary key.
-     * Can be used only for many-to-one and owner one-to-one relations.
-     */
-    isPrimary: boolean;
-    /**
-     * Indicates if this relation is lazily loaded.
-     */
-    isLazy: boolean;
-    /**
-     * Indicates if this relation is eagerly loaded.
-     */
-    isEager: boolean;
-    /**
-     * Indicates if persistence is enabled for the relation.
-     * By default its enabled, but if you want to avoid any changes in the relation to be reflected in the database you can disable it.
-     * If its disabled you can only change a relation from inverse side of a relation or using relation query builder functionality.
-     * This is useful for performance optimization since its disabling avoid multiple extra queries during entity save.
-     */
-    persistenceEnabled: boolean;
-    /**
-     * When a parent is saved (with cascading but) without a child row that still exists in database, this will control what shall happen to them.
-     * delete will remove these rows from database. nullify will remove the relation key.
-     * skip will keep the relation intact. Removal of related item is only possible through its own repo.
-     */
-    orphanedRowAction?: "nullify" | "delete" | "soft-delete" | "disable";
-    /**
-     * If set to true then related objects are allowed to be inserted to the database.
-     */
-    isCascadeInsert: boolean;
-    /**
-     * If set to true then related objects are allowed to be updated in the database.
-     */
-    isCascadeUpdate: boolean;
-    /**
-     * If set to true then related objects are allowed to be remove from the database.
-     */
-    isCascadeRemove: boolean;
-    /**
-     * If set to true then related objects are allowed to be soft-removed from the database.
-     */
-    isCascadeSoftRemove: boolean;
-    /**
-     * If set to true then related objects are allowed to be recovered from the database.
-     */
-    isCascadeRecover: boolean;
-    /**
-     * Indicates if relation column value can be nullable or not.
-     */
-    isNullable: boolean;
-    /**
-     * What to do with a relation on deletion of the row containing a foreign key.
-     */
-    onDelete?: OnDeleteType;
-    /**
-     * What to do with a relation on update of the row containing a foreign key.
-     */
-    onUpdate?: OnUpdateType;
-    /**
-     * What to do with a relation on update of the row containing a foreign key.
-     */
-    deferrable?: DeferrableType;
-    /**
-     * Indicates whether foreign key constraints will be created for join columns.
-     * Can be used only for many-to-one and owner one-to-one relations.
-     * Defaults to true.
-     */
-    createForeignKeyConstraints: boolean;
-    /**
-     * Gets the property's type to which this relation is applied.
-     *
-     * For example for @ManyToMany(type => Category) in Post, target will be Category.
-     */
-    type: Function | string;
-    /**
-     * Indicates if this side is an owner of this relation.
-     */
-    isOwning: boolean;
-    /**
-     * Checks if this relation's type is "one-to-one".
-     */
-    isOneToOne: boolean;
-    /**
-     * Checks if this relation is owner side of the "one-to-one" relation.
-     * Owner side means this side of relation has a join column in the table.
-     */
-    isOneToOneOwner: boolean;
-    /**
-     * Checks if this relation has a join column (e.g. is it many-to-one or one-to-one owner side).
-     */
-    isWithJoinColumn: boolean;
-    /**
-     * Checks if this relation is NOT owner side of the "one-to-one" relation.
-     * NOT owner side means this side of relation does not have a join column in the table.
-     */
-    isOneToOneNotOwner: boolean;
-    /**
-     * Checks if this relation's type is "one-to-many".
-     */
-    isOneToMany: boolean;
-    /**
-     * Checks if this relation's type is "many-to-one".
-     */
-    isManyToOne: boolean;
-    /**
-     * Checks if this relation's type is "many-to-many".
-     */
-    isManyToMany: boolean;
-    /**
-     * Checks if this relation's type is "many-to-many", and is owner side of the relationship.
-     * Owner side means this side of relation has a join table.
-     */
-    isManyToManyOwner: boolean;
-    /**
-     * Checks if this relation's type is "many-to-many", and is NOT owner side of the relationship.
-     * Not owner side means this side of relation does not have a join table.
-     */
-    isManyToManyNotOwner: boolean;
-    /**
-     * Gets the property path of the inverse side of the relation.
-     */
-    inverseSidePropertyPath: string;
-    /**
-     * Inverse side of the relation set by user.
-     *
-     * Inverse side set in the relation can be either string - property name of the column on inverse side,
-     * either can be a function that accepts a map of properties with the object and returns one of them.
-     * Second approach is used to achieve type-safety.
-     */
-    givenInverseSidePropertyFactory: PropertyTypeFactory<any>;
-    /**
-     * Gets the relation metadata of the inverse side of this relation.
-     */
-    inverseRelation?: RelationMetadata;
-    /**
-     * Join table name.
-     */
-    joinTableName: string;
-    /**
-     * Foreign keys created for this relation.
-     */
-    foreignKeys: ForeignKeyMetadata[];
-    /**
-     * Join table columns.
-     * Join columns can be obtained only from owner side of the relation.
-     * From non-owner side of the relation join columns will be empty.
-     * If this relation is a many-to-one/one-to-one then it takes join columns from the current entity.
-     * If this relation is many-to-many then it takes all owner join columns from the junction entity.
-     */
-    joinColumns: ColumnMetadata[];
-    /**
-     * Inverse join table columns.
-     * Inverse join columns are supported only for many-to-many relations
-     * and can be obtained only from owner side of the relation.
-     * From non-owner side of the relation join columns will be undefined.
-     */
-    inverseJoinColumns: ColumnMetadata[];
-    constructor(options: {
-        entityMetadata: EntityMetadata;
-        embeddedMetadata?: EmbeddedMetadata;
-        args: RelationMetadataArgs;
-    });
-    /**
-     * Creates join column ids map from the given related entity ids array.
-     */
-    getRelationIdMap(entity: ObjectLiteral): ObjectLiteral | undefined;
-    /**
-     * Ensures that given object is an entity id map.
-     * If given id is an object then it means its already id map.
-     * If given id isn't an object then it means its a value of the id column
-     * and it creates a new id map with this value and name of the primary column.
-     */
-    ensureRelationIdMap(id: any): ObjectLiteral;
-    /**
-     * Extracts column value from the given entity.
-     * If column is in embedded (or recursive embedded) it extracts its value from there.
-     */
-    getEntityValue(entity: ObjectLiteral, getLazyRelationsPromiseValue?: boolean): any | undefined;
-    /**
-     * Sets given entity's relation's value.
-     * Using of this method helps to set entity relation's value of the lazy and non-lazy relations.
-     *
-     * If merge is set to true, it merges given value into currently
-     */
-    setEntityValue(entity: ObjectLiteral, value: any): void;
-    /**
-     * Creates entity id map from the given entity ids array.
-     */
-    createValueMap(value: any): any;
-    /**
-     * Builds some depend relation metadata properties.
-     * This builder method should be used only after embedded metadata tree was build.
-     */
-    build(): void;
-    /**
-     * Registers given foreign keys in the relation.
-     * This builder method should be used to register foreign key in the relation.
-     */
-    registerForeignKeys(...foreignKeys: ForeignKeyMetadata[]): void;
-    /**
-     * Registers given join columns in the relation.
-     * This builder method should be used to register join column in the relation.
-     */
-    registerJoinColumns(joinColumns?: ColumnMetadata[], inverseJoinColumns?: ColumnMetadata[]): void;
-    /**
-     * Registers a given junction entity metadata.
-     * This builder method can be called after junction entity metadata for the many-to-many relation was created.
-     */
-    registerJunctionEntityMetadata(junctionEntityMetadata: EntityMetadata): void;
-    /**
-     * Builds inverse side property path based on given inverse side property factory.
-     * This builder method should be used only after properties map of the inverse entity metadata was build.
-     */
-    buildInverseSidePropertyPath(): string;
-    /**
-     * Builds relation's property path based on its embedded tree.
-     */
-    buildPropertyPath(): string;
-}

package/client/lib/typeorm/metadata/UniqueMetadata.d.ts

@@ -1,66 +0,0 @@
-// @ts-nocheck
-import { EmbeddedMetadata } from "./EmbeddedMetadata";
-import { EntityMetadata } from "./EntityMetadata";
-import { NamingStrategyInterface } from "../naming-strategy/NamingStrategyInterface";
-import { ColumnMetadata } from "./ColumnMetadata";
-import { UniqueMetadataArgs } from "../metadata-args/UniqueMetadataArgs";
-import { DeferrableType } from "./types/DeferrableType";
-/**
- * Unique metadata contains all information about table's unique constraints.
- */
-export declare class UniqueMetadata {
-    /**
-     * Entity metadata of the class to which this unique constraint is applied.
-     */
-    entityMetadata: EntityMetadata;
-    /**
-     * Embedded metadata if this unique was applied on embedded.
-     */
-    embeddedMetadata?: EmbeddedMetadata;
-    /**
-     * Target class to which metadata is applied.
-     */
-    target?: Function | string;
-    /**
-     * Unique columns.
-     */
-    columns: ColumnMetadata[];
-    /**
-     * Indicate if unique constraints can be deferred.
-     */
-    deferrable?: DeferrableType;
-    /**
-     * User specified unique constraint name.
-     */
-    givenName?: string;
-    /**
-     * User specified column names.
-     */
-    givenColumnNames?: ((object?: any) => any[] | {
-        [key: string]: number;
-    }) | string[];
-    /**
-     * Final unique constraint name.
-     * If unique constraint name was given by a user then it stores normalized (by naming strategy) givenName.
-     * If unique constraint name was not given then its generated.
-     */
-    name: string;
-    /**
-     * Map of column names with order set.
-     * Used only by MongoDB driver.
-     */
-    columnNamesWithOrderingMap: {
-        [key: string]: number;
-    };
-    constructor(options: {
-        entityMetadata: EntityMetadata;
-        embeddedMetadata?: EmbeddedMetadata;
-        columns?: ColumnMetadata[];
-        args?: UniqueMetadataArgs;
-    });
-    /**
-     * Builds some depend unique constraint properties.
-     * Must be called after all entity metadata's properties map, columns and relations are built.
-     */
-    build(namingStrategy: NamingStrategyInterface): this;
-}

package/client/lib/typeorm/metadata/types/ClosureTreeOptions.d.ts

@@ -1,11 +0,0 @@
-// @ts-nocheck
-/**
- * Tree type.
- * Specifies what table pattern will be used for the tree entity.
- */
-import { ColumnMetadata } from "../ColumnMetadata";
-export interface ClosureTreeOptions {
-    closureTableName?: string;
-    ancestorColumnName?: (column: ColumnMetadata) => string;
-    descendantColumnName?: (column: ColumnMetadata) => string;
-}

package/client/lib/typeorm/metadata/types/DeferrableType.d.ts

@@ -1,5 +0,0 @@
-// @ts-nocheck
-/**
- * DEFERRABLE type to be used to specify if foreign key constraints can be deferred.
- */
-export type DeferrableType = "INITIALLY IMMEDIATE" | "INITIALLY DEFERRED";

package/client/lib/typeorm/metadata/types/EventListenerTypes.d.ts

@@ -1,21 +0,0 @@
-// @ts-nocheck
-/**
- * All types that entity listener can be.
- */
-export type EventListenerType = "after-load" | "before-insert" | "after-insert" | "before-update" | "after-update" | "before-remove" | "after-remove" | "before-soft-remove" | "after-soft-remove" | "before-recover" | "after-recover";
-/**
- * Provides a constants for each entity listener type.
- */
-export declare class EventListenerTypes {
-    static AFTER_LOAD: "after-load";
-    static BEFORE_INSERT: "before-insert";
-    static AFTER_INSERT: "after-insert";
-    static BEFORE_UPDATE: "before-update";
-    static AFTER_UPDATE: "after-update";
-    static BEFORE_REMOVE: "before-remove";
-    static AFTER_REMOVE: "after-remove";
-    static BEFORE_SOFT_REMOVE: "before-soft-remove";
-    static AFTER_SOFT_REMOVE: "after-soft-remove";
-    static BEFORE_RECOVER: "before-recover";
-    static AFTER_RECOVER: "after-recover";
-}

package/client/lib/typeorm/metadata/types/OnDeleteType.d.ts

@@ -1,5 +0,0 @@
-// @ts-nocheck
-/**
- * ON_DELETE type to be used to specify delete strategy when some relation is being deleted from the database.
- */
-export type OnDeleteType = "RESTRICT" | "CASCADE" | "SET NULL" | "DEFAULT" | "NO ACTION";

package/client/lib/typeorm/metadata/types/OnUpdateType.d.ts

@@ -1,5 +0,0 @@
-// @ts-nocheck
-/**
- * ON_UPDATE type to be used to specify update strategy when some relation is being updated.
- */
-export type OnUpdateType = "RESTRICT" | "CASCADE" | "SET NULL" | "DEFAULT" | "NO ACTION";

package/client/lib/typeorm/metadata/types/PropertyTypeInFunction.d.ts

@@ -1,5 +0,0 @@
-// @ts-nocheck
-/**
- * Contains the name of the property of the object, or the function that returns this name.
- */
-export type PropertyTypeFactory<T> = string | ((t: T) => string | any);

package/client/lib/typeorm/metadata/types/RelationTypeInFunction.d.ts

@@ -1,6 +0,0 @@
-// @ts-nocheck
-import { EntityTarget } from "../../common/EntityTarget";
-/**
- * Function that returns a type of the field. Returned value must be a class used on the relation.
- */
-export type RelationTypeInFunction = ((type?: any) => Function) | EntityTarget<any>;

package/client/lib/typeorm/metadata/types/RelationTypes.d.ts

@@ -1,5 +0,0 @@
-// @ts-nocheck
-/**
- * All types that relation can be.
- */
-export type RelationType = "one-to-one" | "one-to-many" | "many-to-one" | "many-to-many";

package/client/lib/typeorm/metadata/types/TableTypes.d.ts

@@ -1,5 +0,0 @@
-// @ts-nocheck
-/**
- * Table type. Tables can be closure, junction,, etc.
- */
-export type TableType = "regular" | "view" | "junction" | "closure" | "closure-junction" | "entity-child";

package/client/lib/typeorm/metadata/types/TreeTypes.d.ts

@@ -1,6 +0,0 @@
-// @ts-nocheck
-/**
- * Tree type.
- * Specifies what table pattern will be used for the tree entity.
- */
-export type TreeType = "adjacency-list" | "closure-table" | "nested-set" | "materialized-path";

package/client/lib/typeorm/metadata-args/CheckMetadataArgs.d.ts

@@ -1,18 +0,0 @@
-// @ts-nocheck
-/**
- * Arguments for CheckMetadata class.
- */
-export interface CheckMetadataArgs {
-    /**
-     * Class to which index is applied.
-     */
-    target: Function | string;
-    /**
-     * Check constraint name.
-     */
-    name?: string;
-    /**
-     * Check expression.
-     */
-    expression: string;
-}