archive-gh-me/typeorm
1
0
Fork 0
mirror of https://github.com/typeorm/typeorm.git synced 2025-12-08 21:26:23 +00:00
Code Issues Projects Releases Wiki Activity

entity metadata refactoring - phase III

Browse Source
This commit is contained in:
Umed Khudoiberdiev 2017-05-05 13:22:22 +05:00
parent d5c62f3d6c
commit ad922f6fd8
9 changed files with 117 additions and 182 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

159
src/metadata-builder/EntityMetadataBuilder.ts
View File

@ -63,6 +63,8 @@ export class EntityMetadataBuilder {
const realTables = allTableMetadataArgs.filter(table => table.type === "regular" || table.type === "closure" || table.type === "class-table-child");
realTables.forEach(tableArgs => {
const entityMetadata = new EntityMetadata(this.lazyRelationsWrapper);
entityMetadata.namingStrategy = this.namingStrategy;
const inheritanceTree = tableArgs.target instanceof Function ? MetadataArgsUtils.getInheritanceTree(tableArgs.target) : [tableArgs.target]; // todo: implement later here inheritance for string-targets
@ -71,40 +73,31 @@ export class EntityMetadataBuilder {
return embeddedArgs.map(embeddedArgs => {
const embeddedType = embeddedArgs.type();
const columns = MetadataArgsUtils.filterByTarget(allColumns, [embeddedType])
.map(columnArgs => new ColumnMetadata(columnArgs));
.map(columnArgs => new ColumnMetadata(entityMetadata, columnArgs));
const relations = MetadataArgsUtils.filterByTarget(allRelations, [embeddedType])
.map(relationArgs => new RelationMetadata(relationArgs));
.map(relationArgs => new RelationMetadata(entityMetadata, relationArgs));
const subEmbeddeds = findEmbeddedsRecursively(MetadataArgsUtils.filterByTarget(allEmbeddeds, [embeddedType]));
return new EmbeddedMetadata(columns, relations, subEmbeddeds, embeddedArgs);
return new EmbeddedMetadata(entityMetadata, columns, relations, subEmbeddeds, embeddedArgs);
});
};
const embeddeds = findEmbeddedsRecursively(MetadataArgsUtils.filterByTarget(allEmbeddeds, inheritanceTree));
const columns = MetadataArgsUtils.filterByTarget(allColumns, inheritanceTree).map(args => new ColumnMetadata(entityMetadata, args));
const relations = MetadataArgsUtils.filterByTarget(allRelations, inheritanceTree).map(args => new RelationMetadata(entityMetadata, args));
const relationIds = MetadataArgsUtils.filterByTarget(allRelationIds, inheritanceTree).map(args => new RelationIdMetadata(entityMetadata, args));
const relationCounts = MetadataArgsUtils.filterByTarget(allRelationCounts, inheritanceTree).map(args => new RelationCountMetadata(entityMetadata, args));
const indices = MetadataArgsUtils.filterByTarget(allIndices, inheritanceTree).map(args => new IndexMetadata(entityMetadata, args));
const columns = MetadataArgsUtils.filterByTarget(allColumns, inheritanceTree).map(args => new ColumnMetadata(args));
const relations = MetadataArgsUtils.filterByTarget(allRelations, inheritanceTree).map(args => new RelationMetadata(args));
const relationIds = MetadataArgsUtils.filterByTarget(allRelationIds, inheritanceTree).map(args => new RelationIdMetadata(args));
const relationCounts = MetadataArgsUtils.filterByTarget(allRelationCounts, inheritanceTree).map(args => new RelationCountMetadata(args));
const indices = MetadataArgsUtils.filterByTarget(allIndices, inheritanceTree).map(args => new IndexMetadata(args));
entityMetadata._orderBy = tableArgs.orderBy;
entityMetadata.ownColumns = columns;
entityMetadata.ownRelations = relations;
entityMetadata.relationIds = relationIds;
entityMetadata.relationCounts = relationCounts;
entityMetadata.indices = indices;
entityMetadata.embeddeds = embeddeds;
// inheritanceType: mergedArgs.inheritance ? mergedArgs.inheritance.type : undefined,
// discriminatorValue: discriminatorValueArgs ? discriminatorValueArgs.value : (tableArgs.target as any).name // todo: pass this to naming strategy to generate a name
// create a new entity metadata
const entityMetadata = new EntityMetadata({
junction: false,
target: tableArgs.target,
tablesPrefix: this.driver.options.tablesPrefix,
namingStrategy: this.namingStrategy,
tableName: tableArgs.name,
tableType: tableArgs.type,
orderBy: tableArgs.orderBy,
columnMetadatas: columns,
relationMetadatas: relations,
relationIdMetadatas: relationIds,
relationCountMetadatas: relationCounts,
indexMetadatas: indices,
embeddedMetadatas: embeddeds,
// inheritanceType: mergedArgs.inheritance ? mergedArgs.inheritance.type : undefined,
// discriminatorValue: discriminatorValueArgs ? discriminatorValueArgs.value : (tableArgs.target as any).name // todo: pass this to naming strategy to generate a name
}, this.lazyRelationsWrapper);
this.createEntityMetadata(entityMetadata, {
target: tableArgs.target,
tableType: tableArgs.type,
@ -143,7 +136,7 @@ export class EntityMetadataBuilder {
.forEach(metadata => {
const parentEntityMetadataPrimaryColumn = metadata.parentEntityMetadata.firstPrimaryColumn; // todo: make sure to create columns for all its primary columns
const columnName = this.namingStrategy.classTableInheritanceParentColumnName(metadata.parentEntityMetadata.tableName, parentEntityMetadataPrimaryColumn.propertyName);
const parentRelationColumn = new ColumnMetadata({
const parentRelationColumn = new ColumnMetadata(metadata, {
target: metadata.parentEntityMetadata.target,
propertyName: parentEntityMetadataPrimaryColumn.propertyName,
// propertyType: parentEntityMetadataPrimaryColumn.propertyType,
@ -162,13 +155,12 @@ export class EntityMetadataBuilder {
// add foreign key
const foreignKey = new ForeignKeyMetadata(
metadata,
[parentRelationColumn],
metadata.parentEntityMetadata,
[parentEntityMetadataPrimaryColumn],
"CASCADE"
);
foreignKey.entityMetadata = metadata;
// parentRelationColumn.foreignKey =
metadata.foreignKeys.push(foreignKey);
});
@ -235,7 +227,7 @@ export class EntityMetadataBuilder {
let relationalColumn = relation.entityMetadata.columns.find(column => column.fullName === joinColumnName);
if (!relationalColumn) {
relationalColumn = new ColumnMetadata({
relationalColumn = new ColumnMetadata(entityMetadata, {
target: relation.entityMetadata.target,
propertyName: joinColumnName!,
mode: "virtual",
@ -253,23 +245,19 @@ export class EntityMetadataBuilder {
});
const foreignKey = new ForeignKeyMetadata(
entityMetadata,
columns,
relation.inverseEntityMetadata,
referencedColumns,
relation.onDelete
);
foreignKey.entityMetadata = relation.entityMetadata;
relation.foreignKeys = [foreignKey];
relation.entityMetadata.foreignKeys.push(foreignKey);
});
});
entityMetadatas.forEach(entityMetadata => {
// const mergedArgs = allMergedArgs.find(mergedArgs => {
// return mergedArgs.table.target === entityMetadata.target;
// });
// if (!mergedArgs) return;
// create entity's relations join columns
entityMetadata.manyToManyRelations.forEach(relation => {
@ -312,37 +300,7 @@ export class EntityMetadataBuilder {
return referencedColumn;
});
}
// return joinColumnArgsArray.map(joinColumnMetadataArgs => {
// const joinColumn = new JoinColumnMetadata();
// joinColumn.relation = relation;
// joinColumn.target = joinColumnMetadataArgs.target;
// joinColumn.propertyName = joinColumnMetadataArgs.propertyName;
// const referencedColumn = columnMetadatas.find(column => {
// return column.propertyName === joinColumnMetadataArgs.referencedColumnName;
// });
// if (!referencedColumn)
// throw new Error(`Referenced column ${joinColumnMetadataArgs.referencedColumnName} was not found in entity ${relation.inverseEntityMetadata.name}`); // todo: fix ${relation.inverseEntityMetadata.name}
//
// joinColumn.referencedColumn = referencedColumn;
// joinColumn.name = joinColumnMetadataArgs.name || columnNameFactory(joinColumn.referencedColumn.propertyName);
// return joinColumn;
// });
//
// const columns = this.createJoinColumns(
// joinTableMetadataArgs.joinColumns || [],
// relation.entityMetadata.primaryColumnsWithParentIdColumns,
// relation.entityMetadata.allColumns,
// relation,
// (columnName => namingStrategy.joinTableColumnName(relation.entityMetadata.table.nameWithoutPrefix, columnName))
// );
// const inverseJoinColumns = this.createJoinColumns(
// joinTableMetadataArgs.inverseJoinColumns || [],
// relation.inverseEntityMetadata.primaryColumnsWithParentIdColumns,
// relation.inverseEntityMetadata.allColumns,
// relation,
// (columnName => namingStrategy.joinTableColumnName(relation.inverseEntityMetadata.table.nameWithoutPrefix, columnName))
// );
const junctionEntityMetadata = new EntityMetadata(this.lazyRelationsWrapper);
const junctionColumns = referencedColumns.map(referencedColumn => {
const joinColumn = joinTableMetadataArgs.joinColumns ? joinTableMetadataArgs.joinColumns.find(joinColumnArgs => {
@ -351,7 +309,7 @@ export class EntityMetadataBuilder {
}) : undefined;
const columnName = joinColumn && joinColumn.name ? joinColumn.name : this.namingStrategy.joinTableColumnName(relation.entityMetadata.tableNameWithoutPrefix, referencedColumn.fullName);
return new ColumnMetadata({
return new ColumnMetadata(junctionEntityMetadata, {
target: "__virtual__",
propertyName: columnName,
mode: "virtual",
@ -372,7 +330,7 @@ export class EntityMetadataBuilder {
}) : undefined;
const columnName = joinColumn && joinColumn.name ? joinColumn.name : this.namingStrategy.joinTableColumnName(relation.inverseEntityMetadata.tableNameWithoutPrefix, inverseReferencedColumn.fullName);
return new ColumnMetadata({
return new ColumnMetadata(junctionEntityMetadata, {
target: "__virtual__",
propertyName: columnName,
mode: "virtual",
@ -387,32 +345,25 @@ export class EntityMetadataBuilder {
});
const foreignKeys = [
new ForeignKeyMetadata(junctionColumns, relation.entityMetadata, referencedColumns),
new ForeignKeyMetadata(inverseJunctionColumns, relation.inverseEntityMetadata, inverseReferencedColumns)
new ForeignKeyMetadata(junctionEntityMetadata, junctionColumns, relation.entityMetadata, referencedColumns),
new ForeignKeyMetadata(junctionEntityMetadata, inverseJunctionColumns, relation.inverseEntityMetadata, inverseReferencedColumns)
];
junctionColumns.concat(inverseJunctionColumns).forEach(column => column.relationMetadata = relation);
const junctionEntityMetadata = new EntityMetadata({
junction: true,
target: "__virtual__",
tablesPrefix: this.driver.options.tablesPrefix,
namingStrategy: this.namingStrategy,
tableName: joinTableName,
tableType: "junction",
columnMetadatas: junctionColumns.concat(inverseJunctionColumns),
foreignKeyMetadatas: foreignKeys,
indexMetadatas: [ // todo: shall we remove indices?
new IndexMetadata({ columns: junctionColumns.map(column => column.fullName), unique: false }),
new IndexMetadata({ columns: inverseJunctionColumns.map(column => column.fullName), unique: false })
]
}, this.lazyRelationsWrapper);
junctionEntityMetadata.isJunction = true;
junctionEntityMetadata.target = "__virtual__";
junctionEntityMetadata.namingStrategy = this.namingStrategy;
junctionEntityMetadata.ownColumns = junctionColumns.concat(inverseJunctionColumns);
junctionEntityMetadata.foreignKeys = foreignKeys;
junctionEntityMetadata.indices = [ // todo: shall we remove indices?
new IndexMetadata(junctionEntityMetadata, { columns: junctionColumns.map(column => column.fullName), unique: false }),
new IndexMetadata(junctionEntityMetadata, { columns: inverseJunctionColumns.map(column => column.fullName), unique: false })
];
this.createEntityMetadata(junctionEntityMetadata, {
tableType: "junction",
userSpecifiedTableName: joinTableName,
});
junctionEntityMetadata.columns.forEach(column => column.entityMetadata = entityMetadata);
relation.foreignKeys = foreignKeys;
relation.junctionEntityMetadata = junctionEntityMetadata;
if (relation.hasInverseSide)
@ -427,20 +378,18 @@ export class EntityMetadataBuilder {
entityMetadatas
.filter(metadata => metadata.inheritanceType === "single-table" && metadata.hasDiscriminatorColumn)
.forEach(metadata => {
const indexForKey = new IndexMetadata({
const indexForKey = new IndexMetadata(metadata, {
target: metadata.target,
columns: [metadata.discriminatorColumn.fullName],
unique: false
});
indexForKey.entityMetadata = metadata;
metadata.indices.push(indexForKey);
const indexForKeyWithPrimary = new IndexMetadata({
const indexForKeyWithPrimary = new IndexMetadata(metadata, {
target: metadata.target,
columns: [metadata.firstPrimaryColumn.propertyName, metadata.discriminatorColumn.propertyName],
unique: false
});
indexForKeyWithPrimary.entityMetadata = metadata;
metadata.indices.push(indexForKeyWithPrimary);
});
@ -498,8 +447,10 @@ export class EntityMetadataBuilder {
if (metadata.primaryColumns.length > 1)
throw new Error(`Cannot use given entity ${metadata.name} as a closure table, because it have multiple primary keys. Entities with multiple primary keys are not supported in closure tables.`);
const closureJunctionEntityMetadata = new EntityMetadata(this.lazyRelationsWrapper);
const columns = [
new ColumnMetadata(<ColumnMetadataArgs> {
new ColumnMetadata(closureJunctionEntityMetadata, <ColumnMetadataArgs> {
target: "__virtual__",
propertyName: "__virtual__",
propertyType: metadata.firstPrimaryColumn.type,
@ -510,7 +461,7 @@ export class EntityMetadataBuilder {
name: "ancestor"
}
}),
new ColumnMetadata(<ColumnMetadataArgs> {
new ColumnMetadata(closureJunctionEntityMetadata, <ColumnMetadataArgs> {
target: "__virtual__",
propertyName: "__virtual__",
propertyType: metadata.firstPrimaryColumn.type,
@ -524,7 +475,7 @@ export class EntityMetadataBuilder {
];
if (metadata.hasTreeLevelColumn) {
columns.push(new ColumnMetadata(<ColumnMetadataArgs> {
columns.push(new ColumnMetadata(closureJunctionEntityMetadata, <ColumnMetadataArgs> {
target: "__virtual__",
propertyName: "__virtual__",
propertyType: ColumnTypes.INTEGER,
@ -536,19 +487,13 @@ export class EntityMetadataBuilder {
}));
}
const closureJunctionEntityMetadata = new EntityMetadata({
junction: true,
target: "__virtual__",
tablesPrefix: this.driver.options.tablesPrefix,
namingStrategy: this.namingStrategy,
tableName: metadata.tableName,
tableType: "closure-junction",
columnMetadatas: columns,
foreignKeyMetadatas: [
new ForeignKeyMetadata([columns[0]], metadata, [metadata.firstPrimaryColumn]),
new ForeignKeyMetadata([columns[1]], metadata, [metadata.firstPrimaryColumn])
]
}, this.lazyRelationsWrapper);
closureJunctionEntityMetadata.isJunction = true;
closureJunctionEntityMetadata.target = "__virtual__";
closureJunctionEntityMetadata.ownColumns = columns;
closureJunctionEntityMetadata.foreignKeys = [
new ForeignKeyMetadata(closureJunctionEntityMetadata, [columns[0]], metadata, [metadata.firstPrimaryColumn]),
new ForeignKeyMetadata(closureJunctionEntityMetadata, [columns[1]], metadata, [metadata.firstPrimaryColumn])
];
this.createEntityMetadata(closureJunctionEntityMetadata, {
tableType: "closure-junction",
closureOwnerTableName: metadata.tableName,
@ -591,6 +536,7 @@ export class EntityMetadataBuilder {
// for virtual tables (like junction table) target is equal to undefined at this moment
// we change this by setting virtual's table name to a target name
// todo: add validation so targets with same schema names won't conflicts with virtual table names
metadata.tableType = tableType;
metadata.target = target ? target : tableName;
metadata.targetName = targetName;
metadata.tableNameUserSpecified = tableNameUserSpecified;
@ -599,6 +545,7 @@ export class EntityMetadataBuilder {
metadata.name = targetName ? targetName : tableName;
metadata.engine = options.engine;
metadata.skipSchemaSync = options.skipSchemaSync || false;
metadata.namingStrategy = this.namingStrategy;
}
/*protected createEntityMetadata(tableArgs: any, argsForTable: any, ): EntityMetadata {

3
src/metadata/ColumnMetadata.ts
View File

@ -147,7 +147,8 @@ export class ColumnMetadata {
// Constructor
// ---------------------------------------------------------------------
constructor(args: ColumnMetadataArgs) {
constructor(entityMetadata: EntityMetadata, args: ColumnMetadataArgs) {
this.entityMetadata = entityMetadata;
this.target = args.target;
this.propertyName = args.propertyName;

11
src/metadata/EmbeddedMetadata.ts
View File

@ -1,6 +1,7 @@
import {ColumnMetadata} from "./ColumnMetadata";
import {EmbeddedMetadataArgs} from "../metadata-args/EmbeddedMetadataArgs";
import {RelationMetadata} from "./RelationMetadata";
import {EntityMetadata} from "./EntityMetadata";
/**
* Contains all information about entity's embedded property.
@ -11,6 +12,12 @@ export class EmbeddedMetadata {
// Public Properties
// ---------------------------------------------------------------------
/**
* Entity metadata where this embedded is.
*/
entityMetadata: EntityMetadata;
/**
* Parent embedded in the case if this embedded inside other embedded.
*/
@ -58,10 +65,12 @@ export class EmbeddedMetadata {
// Constructor
// ---------------------------------------------------------------------
constructor(columns: ColumnMetadata[],
constructor(entityMetadata: EntityMetadata,
columns: ColumnMetadata[],
relations: RelationMetadata[],
embeddeds: EmbeddedMetadata[],
args: EmbeddedMetadataArgs) {
this.entityMetadata = entityMetadata;
this.type = args.type ? args.type() : undefined;
this.propertyName = args.propertyName;
this.isArray = args.isArray;

110
src/metadata/EntityMetadata.ts
View File

@ -41,55 +41,57 @@ export class EntityMetadata {
/**
* Naming strategy used to generate and normalize names.
*
* @deprecated
*/
readonly namingStrategy: NamingStrategyInterface;
namingStrategy: NamingStrategyInterface;
/**
* Specifies a default order by used for queries from this table when no explicit order by is specified.
*/
readonly _orderBy?: OrderByCondition|((object: any) => OrderByCondition|any);
_orderBy?: OrderByCondition|((object: any) => OrderByCondition|any);
/**
* Entity's relation metadatas.
*/
private readonly _relations: RelationMetadata[];
ownRelations: RelationMetadata[] = [];
/**
* Entity's relation id metadatas.
*/
readonly relationIds: RelationIdMetadata[];
relationIds: RelationIdMetadata[] = [];
/**
* Entity's relation id metadatas.
*/
readonly relationCounts: RelationCountMetadata[];
relationCounts: RelationCountMetadata[] = [];
/**
* Entity's index metadatas.
*/
readonly indices: IndexMetadata[];
indices: IndexMetadata[] = [];
/**
* Entity's foreign key metadatas.
*/
readonly foreignKeys: ForeignKeyMetadata[] = [];
foreignKeys: ForeignKeyMetadata[] = [];
/**
* Entity's embedded metadatas.
*/
readonly embeddeds: EmbeddedMetadata[];
embeddeds: EmbeddedMetadata[] = [];
/**
* If this entity metadata's table using one of the inheritance patterns,
* then this will contain what pattern it uses.
*/
readonly inheritanceType?: "single-table"|"class-table";
inheritanceType?: "single-table"|"class-table";
/**
* If this entity metadata is a child table of some table, it should have a discriminator value.
* Used to store a value in a discriminator column.
*/
readonly discriminatorValue?: string;
discriminatorValue?: string;
// -------------------------------------------------------------------------
// Private properties
@ -98,43 +100,13 @@ export class EntityMetadata {
/**
* Entity's column metadatas.
*/
private readonly _columns: ColumnMetadata[];
ownColumns: ColumnMetadata[] = [];
// -------------------------------------------------------------------------
// Constructor
// -------------------------------------------------------------------------
constructor(args: EntityMetadataArgs,
private lazyRelationsWrapper: LazyRelationsWrapper) {
this.target = args.target;
this.isJunction = args.junction;
this.namingStrategy = args.namingStrategy;
this.tableType = args.tableType;
this._columns = args.columnMetadatas || [];
this._relations = args.relationMetadatas || [];
this.relationIds = args.relationIdMetadatas || [];
this.relationCounts = args.relationCountMetadatas || [];
this.indices = args.indexMetadatas || [];
this.foreignKeys = args.foreignKeyMetadatas || [];
this.embeddeds = args.embeddedMetadatas || [];
this.discriminatorValue = args.discriminatorValue;
this.inheritanceType = args.inheritanceType;
this._orderBy = args.orderBy;
this._columns.forEach(column => column.entityMetadata = this);
this._relations.forEach(relation => relation.entityMetadata = this);
this.relationIds.forEach(relationId => relationId.entityMetadata = this);
this.relationCounts.forEach(relationCount => relationCount.entityMetadata = this);
this.foreignKeys.forEach(foreignKey => foreignKey.entityMetadata = this);
this.indices.forEach(index => index.entityMetadata = this);
const setEmbeddedEntityMetadataRecursively = (embeddeds: EmbeddedMetadata[]) => {
embeddeds.forEach(embedded => {
embedded.columns.forEach(column => column.entityMetadata = this);
embedded.relations.forEach(relation => relation.entityMetadata = this);
setEmbeddedEntityMetadataRecursively(embedded.embeddeds);
});
};
setEmbeddedEntityMetadataRecursively(this.embeddeds);
constructor(private lazyRelationsWrapper: LazyRelationsWrapper) {
}
// -------------------------------------------------------------------------
@ -159,7 +131,7 @@ export class EntityMetadata {
*
* Its also possible to understand if entity is junction via tableType.
*/
isJunction: boolean;
isJunction: boolean = false;
/**
* Entity's name.
@ -232,7 +204,7 @@ export class EntityMetadata {
* Relations of the entity, including relations that are coming from the embeddeds of this entity.
*/
get relations(): RelationMetadata[] {
return this.embeddeds.reduce((relations, embedded) => relations.concat(embedded.relationsFromTree), this._relations);
return this.embeddeds.reduce((relations, embedded) => relations.concat(embedded.relationsFromTree), this.ownRelations);
}
/**
@ -240,14 +212,14 @@ export class EntityMetadata {
* @deprecated
*/
get columns(): ColumnMetadata[] {
return this.embeddeds.reduce((columns, embedded) => columns.concat(embedded.columnsFromTree), this._columns);
return this.embeddeds.reduce((columns, embedded) => columns.concat(embedded.columnsFromTree), this.ownColumns);
}
/**
* Gets columns without embedded columns.
*/
get columnsWithoutEmbeddeds(): ColumnMetadata[] {
return this._columns;
return this.ownColumns;
}
/**
@ -315,7 +287,7 @@ export class EntityMetadata {
* Gets the generated column if it exists, or returns undefined if it does not.
*/
get generatedColumnIfExist(): ColumnMetadata|undefined {
return this._columns.find(column => column.isGenerated);
return this.ownColumns.find(column => column.isGenerated);
}
/**
@ -333,11 +305,11 @@ export class EntityMetadata {
* Gets the primary columns.
*/
get primaryColumns(): ColumnMetadata[] {
// const originalPrimaryColumns = this._columns.filter(column => column.isPrimary);
// const originalPrimaryColumns = this.ownColumns.filter(column => column.isPrimary);
// const parentEntityPrimaryColumns = this.hasParentIdColumn ? [this.parentIdColumn] : [];
// return originalPrimaryColumns.concat(parentEntityPrimaryColumns);
return this.columns.filter(column => column.isPrimary);
// const originalPrimaryColumns = this._columns.filter(column => column.isPrimary);
// const originalPrimaryColumns = this.ownColumns.filter(column => column.isPrimary);
// const parentEntityPrimaryColumns = this.parentEntityMetadata ? this.parentEntityMetadata.primaryColumns : [];
// return originalPrimaryColumns.concat(parentEntityPrimaryColumns);
}
@ -368,21 +340,21 @@ export class EntityMetadata {
* Gets only primary columns owned by this entity.
*/
get ownPimaryColumns(): ColumnMetadata[] {
return this._columns.filter(column => column.isPrimary);
return this.ownColumns.filter(column => column.isPrimary);
}
/**
* Checks if entity has a create date column.
*/
get hasCreateDateColumn(): boolean {
return !!this._columns.find(column => column.mode === "createDate");
return !!this.ownColumns.find(column => column.mode === "createDate");
}
/**
* Gets entity column which contains a create date value.
*/
get createDateColumn(): ColumnMetadata {
const column = this._columns.find(column => column.mode === "createDate");
const column = this.ownColumns.find(column => column.mode === "createDate");
if (!column)
throw new Error(`CreateDateColumn was not found in entity ${this.name}`);
@ -393,14 +365,14 @@ export class EntityMetadata {
* Checks if entity has an update date column.
*/
get hasUpdateDateColumn(): boolean {
return !!this._columns.find(column => column.mode === "updateDate");
return !!this.ownColumns.find(column => column.mode === "updateDate");
}
/**
* Gets entity column which contains an update date value.
*/
get updateDateColumn(): ColumnMetadata {
const column = this._columns.find(column => column.mode === "updateDate");
const column = this.ownColumns.find(column => column.mode === "updateDate");
if (!column)
throw new Error(`UpdateDateColumn was not found in entity ${this.name}`);
@ -411,14 +383,14 @@ export class EntityMetadata {
* Checks if entity has a version column.
*/
get hasVersionColumn(): boolean {
return !!this._columns.find(column => column.mode === "version");
return !!this.ownColumns.find(column => column.mode === "version");
}
/**
* Gets entity column which contains an entity version.
*/
get versionColumn(): ColumnMetadata {
const column = this._columns.find(column => column.mode === "version");
const column = this.ownColumns.find(column => column.mode === "version");
if (!column)
throw new Error(`VersionColumn was not found in entity ${this.name}`);
@ -429,14 +401,14 @@ export class EntityMetadata {
* Checks if entity has a discriminator column.
*/
get hasDiscriminatorColumn(): boolean {
return !!this._columns.find(column => column.mode === "discriminator");
return !!this.ownColumns.find(column => column.mode === "discriminator");
}
/**
* Gets the discriminator column used to store entity identificator in single-table inheritance tables.
*/
get discriminatorColumn(): ColumnMetadata {
const column = this._columns.find(column => column.mode === "discriminator");
const column = this.ownColumns.find(column => column.mode === "discriminator");
if (!column)
throw new Error(`DiscriminatorColumn was not found in entity ${this.name}`);
@ -447,11 +419,11 @@ export class EntityMetadata {
* Checks if entity has a tree level column.
*/
get hasTreeLevelColumn(): boolean {
return !!this._columns.find(column => column.mode === "treeLevel");
return !!this.ownColumns.find(column => column.mode === "treeLevel");
}
get treeLevelColumn(): ColumnMetadata {
const column = this._columns.find(column => column.mode === "treeLevel");
const column = this.ownColumns.find(column => column.mode === "treeLevel");
if (!column)
throw new Error(`TreeLevelColumn was not found in entity ${this.name}`);
@ -462,11 +434,11 @@ export class EntityMetadata {
* Checks if entity has a tree level column.
*/
get hasParentIdColumn(): boolean {
return !!this._columns.find(column => column.mode === "parentId");
return !!this.ownColumns.find(column => column.mode === "parentId");
}
get parentIdColumn(): ColumnMetadata {
const column = this._columns.find(column => column.mode === "parentId");
const column = this.ownColumns.find(column => column.mode === "parentId");
if (!column)
throw new Error(`Parent id column was not found in entity ${this.name}`);
@ -474,21 +446,21 @@ export class EntityMetadata {
}
get parentIdColumns(): ColumnMetadata[] {
return this._columns.filter(column => column.mode === "parentId");
return this.ownColumns.filter(column => column.mode === "parentId");
}
/**
* Checks if entity has an object id column.
*/
get hasObjectIdColumn(): boolean {
return !!this._columns.find(column => column.mode === "objectId");
return !!this.ownColumns.find(column => column.mode === "objectId");
}
/**
* Gets the object id column used with mongodb database.
*/
get objectIdColumn(): ColumnMetadata {
const column = this._columns.find(column => column.mode === "objectId");
const column = this.ownColumns.find(column => column.mode === "objectId");
if (!column)
throw new Error(`ObjectId was not found in entity ${this.name}`);
@ -821,14 +793,14 @@ export class EntityMetadata {
}
getColumnByPropertyName(propertyName: string) {
return this._columns.find(column => column.propertyName === propertyName);
return this.ownColumns.find(column => column.propertyName === propertyName);
}
/**
* Checks if column with the given property name exist.
*/
hasColumnWithPropertyName(propertyName: string): boolean {
return !!this._columns.find(column => column.propertyName === propertyName);
return !!this.ownColumns.find(column => column.propertyName === propertyName);
}
@ -843,7 +815,7 @@ export class EntityMetadata {
* Checks if column with the given database name exist.
*/
hasColumnWithDbName(name: string): boolean {
return !!this._columns.find(column => column.fullName === name);
return !!this.ownColumns.find(column => column.fullName === name);
}
/**
@ -894,7 +866,7 @@ export class EntityMetadata {
}
addColumn(column: ColumnMetadata) {
this._columns.push(column);
this.ownColumns.push(column);
column.entityMetadata = this;
}

4
src/metadata/ForeignKeyMetadata.ts
View File

@ -48,10 +48,12 @@ export class ForeignKeyMetadata {
// Constructor
// -------------------------------------------------------------------------
constructor(columns: ColumnMetadata[],
constructor(entityMetadata: EntityMetadata,
columns: ColumnMetadata[],
referencedEntityMetadata: EntityMetadata,
referencedColumns: ColumnMetadata[],
onDelete?: OnDeleteType) {
this.entityMetadata = entityMetadata;
this.columns = columns;
this.referencedEntityMetadata = referencedEntityMetadata;
this.referencedColumns = referencedColumns;

3
src/metadata/IndexMetadata.ts
View File

@ -47,7 +47,8 @@ export class IndexMetadata {
// Constructor
// ---------------------------------------------------------------------
constructor(args: IndexMetadataArgs) {
constructor(entityMetadata: EntityMetadata, args: IndexMetadataArgs) {
this.entityMetadata = entityMetadata;
this.target = args.target;
this._columns = args.columns;
this._name = args.name;

3
src/metadata/RelationCountMetadata.ts
View File

@ -50,7 +50,8 @@ export class RelationCountMetadata {
// Constructor
// ---------------------------------------------------------------------
constructor(args: RelationCountMetadataArgs) {
constructor(entityMetadata: EntityMetadata, args: RelationCountMetadataArgs) {
this.entityMetadata = entityMetadata;
this.target = args.target;
this.propertyName = args.propertyName;
this.relationNameOrFactory = args.relation;

3
src/metadata/RelationIdMetadata.ts
View File

@ -50,7 +50,8 @@ export class RelationIdMetadata {
// Constructor
// ---------------------------------------------------------------------
constructor(args: RelationIdMetadataArgs) {
constructor(entityMetadata: EntityMetadata, args: RelationIdMetadataArgs) {
this.entityMetadata = entityMetadata;
this.target = args.target;
this.propertyName = args.propertyName;
this.relationNameOrFactory = args.relation;

3
src/metadata/RelationMetadata.ts
View File

@ -138,7 +138,8 @@ export class RelationMetadata {
// Constructor
// ---------------------------------------------------------------------
constructor(args: RelationMetadataArgs) {
constructor(entityMetadata: EntityMetadata, args: RelationMetadataArgs) {
this.entityMetadata = entityMetadata;
this.target = args.target;
this.propertyName = args.propertyName;
this.relationType = args.relationType;