typeorm 0.2.38-dev.324f1d8

package/browser/metadata/RelationCountMetadata.js

@@ -0,0 +1,35 @@
+import { TypeORMError } from "../error";
+/**
+ * Contains all information about entity's relation count.
+ */
+var RelationCountMetadata = /** @class */ (function () {
+    // ---------------------------------------------------------------------
+    // Constructor
+    // ---------------------------------------------------------------------
+    function RelationCountMetadata(options) {
+        this.entityMetadata = options.entityMetadata;
+        this.target = options.args.target;
+        this.propertyName = options.args.propertyName;
+        this.relationNameOrFactory = options.args.relation;
+        this.alias = options.args.alias;
+        this.queryBuilderFactory = options.args.queryBuilderFactory;
+    }
+    // ---------------------------------------------------------------------
+    // Public Builder Methods
+    // ---------------------------------------------------------------------
+    /**
+     * 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.
+     */
+    RelationCountMetadata.prototype.build = function () {
+        var propertyPath = this.relationNameOrFactory instanceof Function ? this.relationNameOrFactory(this.entityMetadata.propertiesMap) : this.relationNameOrFactory;
+        var relation = this.entityMetadata.findRelationWithPropertyPath(propertyPath);
+        if (!relation)
+            throw new TypeORMError("Cannot find relation " + propertyPath + ". Wrong relation specified for @RelationCount decorator.");
+        this.relation = relation;
+    };
+    return RelationCountMetadata;
+}());
+export { RelationCountMetadata };
+
+//# sourceMappingURL=RelationCountMetadata.js.map

package/browser/metadata/RelationCountMetadata.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../browser/src/metadata/RelationCountMetadata.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAExC;;GAEG;AACH;IAyCI,wEAAwE;IACxE,cAAc;IACd,wEAAwE;IAExE,+BAAY,OAGX;QACG,IAAI,CAAC,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC;QAC7C,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC;QAClC,IAAI,CAAC,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,YAAY,CAAC;QAC9C,IAAI,CAAC,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC;QACnD,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC;QAChC,IAAI,CAAC,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,mBAAmB,CAAC;IAChE,CAAC;IAED,wEAAwE;IACxE,yBAAyB;IACzB,wEAAwE;IAExE;;;OAGG;IACH,qCAAK,GAAL;QACI,IAAM,YAAY,GAAG,IAAI,CAAC,qBAAqB,YAAY,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,cAAc,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,qBAAqB,CAAC;QACjK,IAAM,QAAQ,GAAG,IAAI,CAAC,cAAc,CAAC,4BAA4B,CAAC,YAAY,CAAC,CAAC;QAChF,IAAI,CAAC,QAAQ;YACT,MAAM,IAAI,YAAY,CAAC,0BAAwB,YAAY,6DAA0D,CAAC,CAAC;QAE3H,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC7B,CAAC;IAEL,4BAAC;AAAD,CA1EA,AA0EC,IAAA","file":"RelationCountMetadata.js","sourcesContent":["import {RelationCountMetadataArgs} from \"../metadata-args/RelationCountMetadataArgs\";\nimport {EntityMetadata} from \"./EntityMetadata\";\nimport {RelationMetadata} from \"./RelationMetadata\";\nimport {SelectQueryBuilder} from \"../query-builder/SelectQueryBuilder\";\nimport { TypeORMError } from \"../error\";\n\n/**\n * Contains all information about entity's relation count.\n */\nexport class RelationCountMetadata {\n\n    // ---------------------------------------------------------------------\n    // Public Properties\n    // ---------------------------------------------------------------------\n\n    /**\n     * Entity metadata where this column metadata is.\n     */\n    entityMetadata: EntityMetadata;\n\n    /**\n     * Relation which needs to be counted.\n     */\n    relation: RelationMetadata;\n\n    /**\n     * Relation name which need to count.\n     */\n    relationNameOrFactory: string|((object: any) => any);\n\n    /**\n     * Target class to which metadata is applied.\n     */\n    target: Function|string;\n\n    /**\n     * Target's property name to which this metadata is applied.\n     */\n    propertyName: string;\n\n    /**\n     * Alias of the joined (destination) table.\n     */\n    alias?: string;\n\n    /**\n     * Extra condition applied to \"ON\" section of join.\n     */\n    queryBuilderFactory?: (qb: SelectQueryBuilder<any>) => SelectQueryBuilder<any>;\n\n    // ---------------------------------------------------------------------\n    // Constructor\n    // ---------------------------------------------------------------------\n\n    constructor(options: {\n        entityMetadata: EntityMetadata,\n        args: RelationCountMetadataArgs\n    }) {\n        this.entityMetadata = options.entityMetadata;\n        this.target = options.args.target;\n        this.propertyName = options.args.propertyName;\n        this.relationNameOrFactory = options.args.relation;\n        this.alias = options.args.alias;\n        this.queryBuilderFactory = options.args.queryBuilderFactory;\n    }\n\n    // ---------------------------------------------------------------------\n    // Public Builder Methods\n    // ---------------------------------------------------------------------\n\n    /**\n     * Builds some depend relation count metadata properties.\n     * This builder method should be used only after entity metadata, its properties map and all relations are build.\n     */\n    build() {\n        const propertyPath = this.relationNameOrFactory instanceof Function ? this.relationNameOrFactory(this.entityMetadata.propertiesMap) : this.relationNameOrFactory;\n        const relation = this.entityMetadata.findRelationWithPropertyPath(propertyPath);\n        if (!relation)\n            throw new TypeORMError(`Cannot find relation ${propertyPath}. Wrong relation specified for @RelationCount decorator.`);\n\n        this.relation = relation;\n    }\n\n}\n"],"sourceRoot":".."}

package/browser/metadata/RelationIdMetadata.d.ts

@@ -0,0 +1,53 @@
+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/browser/metadata/RelationIdMetadata.js

@@ -0,0 +1,57 @@
+import { TypeORMError } from "../error";
+/**
+ * Contains all information about entity's relation count.
+ */
+var RelationIdMetadata = /** @class */ (function () {
+    // ---------------------------------------------------------------------
+    // Constructor
+    // ---------------------------------------------------------------------
+    function RelationIdMetadata(options) {
+        this.entityMetadata = options.entityMetadata;
+        this.target = options.args.target;
+        this.propertyName = options.args.propertyName;
+        this.relationNameOrFactory = options.args.relation;
+        this.alias = options.args.alias;
+        this.queryBuilderFactory = options.args.queryBuilderFactory;
+    }
+    // ---------------------------------------------------------------------
+    // Public Methods
+    // ---------------------------------------------------------------------
+    /**
+     * Sets relation id value from the given entity.
+     *
+     * todo: make it to work in embeds as well.
+     */
+    RelationIdMetadata.prototype.setValue = function (entity) {
+        var _this = this;
+        var inverseEntity = this.relation.getEntityValue(entity);
+        if (Array.isArray(inverseEntity)) {
+            entity[this.propertyName] = inverseEntity.map(function (item) {
+                return _this.relation.inverseEntityMetadata.getEntityIdMixedMap(item);
+            }).filter(function (item) { return item !== null && item !== undefined; });
+        }
+        else {
+            var value = this.relation.inverseEntityMetadata.getEntityIdMixedMap(inverseEntity);
+            if (value !== undefined)
+                entity[this.propertyName] = value;
+        }
+    };
+    // ---------------------------------------------------------------------
+    // Public Builder Methods
+    // ---------------------------------------------------------------------
+    /**
+     * Builds some depend relation id properties.
+     * This builder method should be used only after entity metadata, its properties map and all relations are build.
+     */
+    RelationIdMetadata.prototype.build = function () {
+        var propertyPath = this.relationNameOrFactory instanceof Function ? this.relationNameOrFactory(this.entityMetadata.propertiesMap) : this.relationNameOrFactory;
+        var relation = this.entityMetadata.findRelationWithPropertyPath(propertyPath);
+        if (!relation)
+            throw new TypeORMError("Cannot find relation " + propertyPath + ". Wrong relation specified for @RelationId decorator.");
+        this.relation = relation;
+    };
+    return RelationIdMetadata;
+}());
+export { RelationIdMetadata };
+
+//# sourceMappingURL=RelationIdMetadata.js.map

package/browser/metadata/RelationIdMetadata.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../browser/src/metadata/RelationIdMetadata.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAExC;;GAEG;AACH;IAyCI,wEAAwE;IACxE,cAAc;IACd,wEAAwE;IAExE,4BAAY,OAGX;QACG,IAAI,CAAC,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC;QAC7C,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC;QAClC,IAAI,CAAC,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,YAAY,CAAC;QAC9C,IAAI,CAAC,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC;QACnD,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC;QAChC,IAAI,CAAC,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,mBAAmB,CAAC;IAChE,CAAC;IAED,wEAAwE;IACxE,iBAAiB;IACjB,wEAAwE;IAExE;;;;OAIG;IACH,qCAAQ,GAAR,UAAS,MAAqB;QAA9B,iBAaC;QAZG,IAAM,aAAa,GAAG,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;QAE3D,IAAI,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC,EAAE;YAC9B,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,GAAG,aAAa,CAAC,GAAG,CAAC,UAAA,IAAI;gBAC/C,OAAO,KAAI,CAAC,QAAQ,CAAC,qBAAqB,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;YACxE,CAAC,CAAC,CAAC,MAAM,CAAC,UAAA,IAAI,IAAI,OAAA,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,SAAS,EAAnC,CAAmC,CAAC,CAAC;SAE1D;aAAM;YACH,IAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,qBAAqB,CAAC,mBAAmB,CAAC,aAAa,CAAC,CAAC;YACrF,IAAI,KAAK,KAAK,SAAS;gBACnB,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,GAAG,KAAK,CAAC;SACzC;IACL,CAAC;IAED,wEAAwE;IACxE,yBAAyB;IACzB,wEAAwE;IAExE;;;OAGG;IACH,kCAAK,GAAL;QACI,IAAM,YAAY,GAAG,IAAI,CAAC,qBAAqB,YAAY,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,cAAc,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,qBAAqB,CAAC;QACjK,IAAM,QAAQ,GAAG,IAAI,CAAC,cAAc,CAAC,4BAA4B,CAAC,YAAY,CAAC,CAAC;QAChF,IAAI,CAAC,QAAQ;YACT,MAAM,IAAI,YAAY,CAAC,0BAAwB,YAAY,0DAAuD,CAAC,CAAC;QAExH,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC7B,CAAC;IAGL,yBAAC;AAAD,CAnGA,AAmGC,IAAA","file":"RelationIdMetadata.js","sourcesContent":["import {RelationIdMetadataArgs} from \"../metadata-args/RelationIdMetadataArgs\";\nimport {EntityMetadata} from \"./EntityMetadata\";\nimport {RelationMetadata} from \"./RelationMetadata\";\nimport {SelectQueryBuilder} from \"../query-builder/SelectQueryBuilder\";\nimport {ObjectLiteral} from \"../common/ObjectLiteral\";\nimport { TypeORMError } from \"../error\";\n\n/**\n * Contains all information about entity's relation count.\n */\nexport class RelationIdMetadata {\n\n    // ---------------------------------------------------------------------\n    // Public Properties\n    // ---------------------------------------------------------------------\n\n    /**\n     * Entity metadata where this column metadata is.\n     */\n    entityMetadata: EntityMetadata;\n\n    /**\n     * Relation from which ids will be extracted.\n     */\n    relation: RelationMetadata;\n\n    /**\n     * Relation name which need to count.\n     */\n    relationNameOrFactory: string|((object: any) => any);\n\n    /**\n     * Target class to which metadata is applied.\n     */\n    target: Function|string;\n\n    /**\n     * Target's property name to which this metadata is applied.\n     */\n    propertyName: string;\n\n    /**\n     * Alias of the joined (destination) table.\n     */\n    alias?: string;\n\n    /**\n     * Extra condition applied to \"ON\" section of join.\n     */\n    queryBuilderFactory?: (qb: SelectQueryBuilder<any>) => SelectQueryBuilder<any>;\n\n    // ---------------------------------------------------------------------\n    // Constructor\n    // ---------------------------------------------------------------------\n\n    constructor(options: {\n        entityMetadata: EntityMetadata,\n        args: RelationIdMetadataArgs\n    }) {\n        this.entityMetadata = options.entityMetadata;\n        this.target = options.args.target;\n        this.propertyName = options.args.propertyName;\n        this.relationNameOrFactory = options.args.relation;\n        this.alias = options.args.alias;\n        this.queryBuilderFactory = options.args.queryBuilderFactory;\n    }\n\n    // ---------------------------------------------------------------------\n    // Public Methods\n    // ---------------------------------------------------------------------\n\n    /**\n     * Sets relation id value from the given entity.\n     *\n     * todo: make it to work in embeds as well.\n     */\n    setValue(entity: ObjectLiteral) {\n        const inverseEntity = this.relation.getEntityValue(entity);\n\n        if (Array.isArray(inverseEntity)) {\n            entity[this.propertyName] = inverseEntity.map(item => {\n               return this.relation.inverseEntityMetadata.getEntityIdMixedMap(item);\n            }).filter(item => item !== null && item !== undefined);\n\n        } else {\n            const value = this.relation.inverseEntityMetadata.getEntityIdMixedMap(inverseEntity);\n            if (value !== undefined)\n                entity[this.propertyName] = value;\n        }\n    }\n\n    // ---------------------------------------------------------------------\n    // Public Builder Methods\n    // ---------------------------------------------------------------------\n\n    /**\n     * Builds some depend relation id properties.\n     * This builder method should be used only after entity metadata, its properties map and all relations are build.\n     */\n    build() {\n        const propertyPath = this.relationNameOrFactory instanceof Function ? this.relationNameOrFactory(this.entityMetadata.propertiesMap) : this.relationNameOrFactory;\n        const relation = this.entityMetadata.findRelationWithPropertyPath(propertyPath);\n        if (!relation)\n            throw new TypeORMError(`Cannot find relation ${propertyPath}. Wrong relation specified for @RelationId decorator.`);\n\n        this.relation = relation;\n    }\n\n\n}\n"],"sourceRoot":".."}

package/browser/metadata/RelationMetadata.d.ts

@@ -0,0 +1,288 @@
+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 child row is removed from its parent, determines if the child row should be orphaned (default) or deleted.
+     */
+    orphanedRowAction?: "nullify" | "delete";
+    /**
+     * 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;
+}