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

added many to many support in embeddeds

Browse Source
This commit is contained in:
Zotov Dmitry 2017-05-04 10:26:11 +05:00
parent b68bedf70f
commit c0c3de329f
31 changed files with 659 additions and 153 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/decorator/Embedded.ts
View File

@ -6,6 +6,8 @@ import {EmbeddedMetadataArgs} from "../metadata-args/EmbeddedMetadataArgs";
* Property in entity can be marked as Embedded, and on persist all columns from the embedded are mapped to the
* single table of the entity where Embedded is used. And on hydration all columns which supposed to be in the
* embedded will be mapped to it from the single table.
*
* Array option works only in monogodb.
*/
export function Embedded<T>(typeFunction: (type?: any) => ObjectType<T>, options?: { prefix?: string, array?: boolean }) {
return function (object: Object, propertyName: string) {

13
src/metadata-args/MetadataArgsStorage.ts
View File

@ -262,6 +262,7 @@ export class MetadataArgsStorage {
protected mergeWithEmbeddable(allTableMetadatas: TargetMetadataArgsCollection<TableMetadataArgs>,
tableMetadata: TableMetadataArgs) {
const columns = this.columns.filterByTarget(tableMetadata.target);
const relations = this.relations.filterByTarget(tableMetadata.target);
const embeddeds = this.embeddeds.filterByTarget(tableMetadata.target);
allTableMetadatas
@ -279,6 +280,11 @@ export class MetadataArgsStorage {
.toArray()
.forEach(metadata => columns.add(metadata));
metadatasFromParents.relations
.filterRepeatedMetadatas(relations.toArray())
.toArray()
.forEach(metadata => relations.add(metadata));
metadatasFromParents.embeddeds
.filterRepeatedMetadatas(embeddeds.toArray())
.toArray()
@ -288,6 +294,7 @@ export class MetadataArgsStorage {
return {
table: tableMetadata,
columns: columns,
relations: relations,
embeddeds: embeddeds
};
}
@ -302,4 +309,10 @@ export class MetadataArgsStorage {
return Object.getPrototypeOf(target1.prototype).constructor === target2;
}
findJoinTable(target: Function|string, propertyName: string) {
return this.joinTables.toArray().find(joinTable => {
return joinTable.target === target && joinTable.propertyName === propertyName;
});
}
}

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

@ -55,8 +55,9 @@ export class EntityMetadataBuilder {
const embeddableTable = embeddableMergedArgs.find(embeddedMergedArgs => embeddedMergedArgs.table.target === embedded.type());
if (embeddableTable) {
const columns = embeddableTable.columns.toArray().map(args => new ColumnMetadata(args));
const relations = embeddableTable.relations.toArray().map(args => new RelationMetadata(args));
const subEmbeddeds = findEmbeddedsRecursively(embeddableTable.embeddeds.toArray());
embeddeds.push(new EmbeddedMetadata(columns, subEmbeddeds, embedded));
embeddeds.push(new EmbeddedMetadata(columns, relations, subEmbeddeds, embedded));
}
});
return embeddeds;
@ -274,20 +275,20 @@ export class EntityMetadataBuilder {
});
entityMetadatas.forEach(entityMetadata => {
const mergedArgs = allMergedArgs.find(mergedArgs => {
return mergedArgs.table.target === entityMetadata.target;
});
if (!mergedArgs) return;
// const mergedArgs = allMergedArgs.find(mergedArgs => {
// return mergedArgs.table.target === entityMetadata.target;
// });
// if (!mergedArgs) return;
// create entity's relations join columns
entityMetadata.manyToManyRelations.forEach(relation => {
const joinTableMetadataArgs = mergedArgs.joinTables.findByProperty(relation.propertyName);
const joinTableMetadataArgs = metadataArgsStorage.findJoinTable(relation.target, relation.propertyName);
if (!joinTableMetadataArgs) return;
const joinTableName = joinTableMetadataArgs.name || relation.entityMetadata.namingStrategy.joinTableName(
relation.entityMetadata.tableNameWithoutPrefix,
relation.inverseEntityMetadata.tableNameWithoutPrefix,
relation.propertyName,
relation.propertyPath,
relation.hasInverseSide ? relation.inverseRelation.propertyName : ""
);

1
src/metadata-builder/EntityMetadataValidator.ts
View File

@ -108,6 +108,7 @@ export class EntityMetadataValidator {
// todo: check if there are multiple columns on the same column applied.
// todo: check column type if is missing in relational databases (throw new Error(`Column type of ${type} cannot be determined.`);)
// todo: include driver-specific checks. for example in mongodb empty prefixes are not allowed
// todo: if multiple columns with same name - throw exception, including cases when columns are in embeds with same prefixes or without prefix at all
});

59
src/metadata/ColumnMetadata.ts
View File

@ -29,6 +29,7 @@ export class ColumnMetadata {
/**
* Embedded metadata where this column metadata is.
* If this column is not in embed then this property value is undefined.
*/
embeddedMetadata: EmbeddedMetadata;
@ -201,6 +202,21 @@ export class ColumnMetadata {
return this.entityMetadata.namingStrategy.columnName(this.propertyName, this._name);
}
/**
* Gets full path to this column property (including column property 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.
*
* @stable
*/
get propertyPath(): string {
if (!this.embeddedMetadata || !this.embeddedMetadata.parentPropertyNames.length)
return this.propertyName;
return this.embeddedMetadata.parentPropertyNames.join(".") + "." + this.propertyName;
}
/**
* Column name in the database including its embedded prefixes.
*
@ -327,6 +343,9 @@ export class ColumnMetadata {
// Public Methods
// ---------------------------------------------------------------------
/**
* @deprecated
*/
hasEntityValue(entity: any) {
if (!entity)
return false;
@ -348,7 +367,7 @@ export class ColumnMetadata {
*
* @stable
*/
createEntityIdMap(id: any) {
createValueMap(value: any) {
// extract column value from embeds of entity if column is in embedded
if (this.embeddedMetadata) {
@ -372,13 +391,13 @@ export class ColumnMetadata {
extractEmbeddedColumnValue(propertyNames, map[propertyName]);
return map;
}
map[this.propertyName] = id;
map[this.propertyName] = value;
return map;
};
return extractEmbeddedColumnValue(propertyNames, {});
} else { // no embeds - no problems. Simply return column property name and its value of the entity
return { [this.propertyName]: id };
return { [this.propertyName]: value };
}
}
@ -391,7 +410,7 @@ export class ColumnMetadata {
*
* @stable
*/
getEntityValueMap(entity: ObjectLiteral): ObjectLiteral {
getValueMap(entity: ObjectLiteral): ObjectLiteral {
// extract column value from embeds of entity if column is in embedded
if (this.embeddedMetadata) {
@ -431,7 +450,7 @@ export class ColumnMetadata {
*
* @stable
*/
getEntityValue(entity: ObjectLiteral): any|undefined {
getValue(entity: ObjectLiteral): any|undefined {
// extract column value from embeddeds of entity if column is in embedded
if (this.embeddedMetadata) {
@ -458,6 +477,36 @@ export class ColumnMetadata {
}
}
/**
* Sets given entity's column's value.
* Using of this method helps to set entity relation's value of the lazy and non-lazy relations.
*/
setValue(entity: ObjectLiteral, value: any): void {
if (this.embeddedMetadata) {
// first step - we extract all parent properties of the entity relative to this column, e.g. [data, information, counters]
const extractEmbeddedColumnValue = (embeddedMetadatas: EmbeddedMetadata[], map: ObjectLiteral): any => {
// if (!object[embeddedMetadata.propertyName])
// object[embeddedMetadata.propertyName] = embeddedMetadata.create();
const embeddedMetadata = embeddedMetadatas.shift();
if (embeddedMetadata) {
if (!map[embeddedMetadata.propertyName])
map[embeddedMetadata.propertyName] = embeddedMetadata.create();
extractEmbeddedColumnValue(embeddedMetadatas, map[embeddedMetadata.propertyName]);
return map;
}
map[this.propertyName] = value;
return map;
};
return extractEmbeddedColumnValue(this.embeddedMetadata.embeddedMetadataTree, entity);
} else {
entity[this.propertyName] = value;
}
}
// ---------------------------------------------------------------------
// Builder Method
// ---------------------------------------------------------------------

36
src/metadata/EmbeddedMetadata.ts
View File

@ -1,5 +1,6 @@
import {ColumnMetadata} from "./ColumnMetadata";
import {EmbeddedMetadataArgs} from "../metadata-args/EmbeddedMetadataArgs";
import {RelationMetadata} from "./RelationMetadata";
/**
* Contains all information about entity's embedded property.
@ -25,6 +26,11 @@ export class EmbeddedMetadata {
*/
columns: ColumnMetadata[];
/**
* Relations inside this embed.
*/
relations: RelationMetadata[];
/**
* Nested embeddable in this embeddable (which has current embedded as parent embedded).
*/
@ -37,6 +43,8 @@ export class EmbeddedMetadata {
/**
* Indicates if this embedded is in array mode.
*
* This option works only in monogodb.
*/
isArray: boolean;
@ -51,6 +59,7 @@ export class EmbeddedMetadata {
// ---------------------------------------------------------------------
constructor(columns: ColumnMetadata[],
relations: RelationMetadata[],
embeddeds: EmbeddedMetadata[],
args: EmbeddedMetadataArgs) {
this.type = args.type ? args.type() : undefined;
@ -58,6 +67,7 @@ export class EmbeddedMetadata {
this.isArray = args.isArray;
this.customPrefix = args.prefix;
this.columns = columns;
this.relations = relations;
this.embeddeds = embeddeds;
this.embeddeds.forEach(embedded => {
embedded.parentEmbeddedMetadata = this;
@ -65,6 +75,9 @@ export class EmbeddedMetadata {
this.columns.forEach(column => {
column.embeddedMetadata = this;
});
this.relations.forEach(relation => {
relation.embeddedMetadata = this;
});
}
// ---------------------------------------------------------------------
@ -89,7 +102,7 @@ export class EmbeddedMetadata {
* @stable just need move to builder process
*/
get prefix(): string {
const prefix = this.customPrefix ? this.customPrefix : this.propertyName;
const prefix = this.customPrefix !== undefined ? this.customPrefix : this.propertyName;
return this.parentEmbeddedMetadata ? this.parentEmbeddedMetadata.prefix + "_" + prefix : prefix; // todo: use naming strategy instead of "_" !!!
}
@ -106,6 +119,18 @@ export class EmbeddedMetadata {
return this.parentEmbeddedMetadata ? this.parentEmbeddedMetadata.parentPropertyNames.concat(this.propertyName) : [this.propertyName];
}
/**
* Returns embed metadatas from all levels of the parent tree.
*
* example: post[data][information][counters].id where "data", "information" and "counters" are embeds
* this method will return [embed metadata of data, embed metadata of information, embed metadata of counters]
*
* @stable just need move to builder process
*/
get embeddedMetadataTree(): EmbeddedMetadata[] {
return this.parentEmbeddedMetadata ? this.parentEmbeddedMetadata.embeddedMetadataTree.concat(this) : [this];
}
/**
* Returns all columns of this embed and all columns from its child embeds.
*
@ -115,4 +140,13 @@ export class EmbeddedMetadata {
return this.embeddeds.reduce((columns, embedded) => columns.concat(embedded.columnsFromTree), this.columns);
}
/**
* Returns all relations of this embed and all relations from its child embeds.
*
* @stable just need move to builder process
*/
get relationsFromTree(): RelationMetadata[] {
return this.embeddeds.reduce((relations, embedded) => relations.concat(embedded.relationsFromTree), this.relations);
}
}

44
src/metadata/EntityMetadata.ts
View File

@ -68,7 +68,7 @@ export class EntityMetadata {
/**
* Entity's relation metadatas.
*/
readonly relations: RelationMetadata[];
private readonly _relations: RelationMetadata[];
/**
* Entity's relation id metadatas.
@ -149,7 +149,7 @@ export class EntityMetadata {
this._tableName = args.tableName;
this.tableType = args.tableType;
this._columns = args.columnMetadatas || [];
this.relations = args.relationMetadatas || [];
this._relations = args.relationMetadatas || [];
this.relationIds = args.relationIdMetadatas || [];
this.relationCounts = args.relationCountMetadatas || [];
this.indices = args.indexMetadatas || [];
@ -161,7 +161,7 @@ export class EntityMetadata {
this.skipSchemaSync = args.skipSchemaSync;
this._orderBy = args.orderBy;
this._columns.forEach(column => column.entityMetadata = this);
this.relations.forEach(relation => relation.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);
@ -170,6 +170,7 @@ export class EntityMetadata {
const setEmbeddedEntityMetadataRecursively = (embeddeds: EmbeddedMetadata[]) => {
embeddeds.forEach(embedded => {
embedded.columns.forEach(column => column.entityMetadata = this);
embedded.relations.forEach(relation => relation.entityMetadata = this);
setEmbeddedEntityMetadataRecursively(embedded.embeddeds);
});
};
@ -223,6 +224,13 @@ export class EntityMetadata {
return this._orderBy;
}
/**
* 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);
}
/**
* Columns of the entity, including columns that are coming from the embeddeds of this entity.
* @deprecated
@ -645,7 +653,7 @@ export class EntityMetadata {
*/
createEntityIdMap(ids: any[]) {
const primaryColumns = this.parentEntityMetadata ? this.primaryColumnsWithParentIdColumns : this.primaryColumns;
return primaryColumns.reduce((map, column, index) => Object.assign(map, column.createEntityIdMap(ids[index])), {});
return primaryColumns.reduce((map, column, index) => Object.assign(map, column.createValueMap(ids[index])), {});
}
/**
@ -658,7 +666,7 @@ export class EntityMetadata {
isEntityMapEmpty(entity: ObjectLiteral): boolean {
const primaryColumns = this.parentEntityMetadata ? this.primaryColumnsWithParentIdColumns : this.primaryColumns;
return !primaryColumns.every(column => {
const value = column.getEntityValue(entity);
const value = column.getValue(entity);
return value !== null && value !== undefined;
});
}
@ -676,18 +684,7 @@ export class EntityMetadata {
return undefined;
const primaryColumns = this.parentEntityMetadata ? this.primaryColumnsWithParentIdColumns : this.primaryColumns;
const map = primaryColumns.reduce((map, column) => Object.assign(map, column.getEntityValueMap(entity)), {});
// console.log(map);
// const map: ObjectLiteral = {};
// primaryColumns.forEach(column => {
// const entityValue = column.getEntityValue(entity);
// if (entityValue === null || entityValue === undefined)
// return;
// map[column.propertyName] = Object.assign(map, entityValue);
// });
const map = primaryColumns.reduce((map, column) => OrmUtils.mergeDeep(map, column.getValueMap(entity)), {});
return Object.keys(map).length > 0 ? map : undefined;
// const map: ObjectLiteral = {};
@ -723,7 +720,7 @@ export class EntityMetadata {
const map: ObjectLiteral = {};
const primaryColumns = this.parentEntityMetadata ? this.primaryColumnsWithParentIdColumns : this.primaryColumns;
primaryColumns.forEach(column => {
const entityValue = column.getEntityValue(entity);
const entityValue = column.getValue(entity);
if (entityValue === null || entityValue === undefined)
return;
@ -864,6 +861,17 @@ export class EntityMetadata {
return relation;
}
/**
* Finds relation with the given property path.
*/
findRelationWithPropertyPath(propertyPath: string): RelationMetadata {
const relation = this.relations.find(relation => relation.propertyPath === propertyPath);
if (!relation)
throw new Error(`Relation with property path ${propertyPath} in ${this.name} entity was not found.`);
return relation;
}
/**
* Checks if relation with the given name exist.
*/

4
src/metadata/IndexMetadata.ts
View File

@ -89,8 +89,8 @@ export class IndexMetadata {
columnPropertyNames = columnsNamesFromFnResult.map((i: any) => String(i));
}
const columns = this.entityMetadata.columns.filter(column => columnPropertyNames.indexOf(column.propertyName) !== -1);
const missingColumnNames = columnPropertyNames.filter(columnPropertyName => !this.entityMetadata.columns.find(column => column.propertyName === columnPropertyName));
const columns = this.entityMetadata.columns.filter(column => columnPropertyNames.indexOf(column.propertyPath) !== -1);
const missingColumnNames = columnPropertyNames.filter(columnPropertyName => !this.entityMetadata.columns.find(column => column.propertyPath === columnPropertyName));
if (missingColumnNames.length > 0) { // todo: better to extract all validation into single place is possible
// console.log(this.entityMetadata.columns);
throw new Error(`Index ${this._name ? "\"" + this._name + "\" " : ""}contains columns that are missing in the entity: ` + missingColumnNames.join(", "));

95
src/metadata/RelationMetadata.ts
View File

@ -4,6 +4,7 @@ import {ForeignKeyMetadata, OnDeleteType} from "./ForeignKeyMetadata";
import {RelationMetadataArgs} from "../metadata-args/RelationMetadataArgs";
import {ObjectLiteral} from "../common/ObjectLiteral";
import {ColumnMetadata} from "./ColumnMetadata";
import {EmbeddedMetadata} from "./EmbeddedMetadata";
/**
* Function that returns a type of the field. Returned value must be a class used on the relation.
@ -31,6 +32,12 @@ export class RelationMetadata {
*/
entityMetadata: EntityMetadata;
/**
* Embedded metadata where this relation is.
* If this relation is not in embed then this property value is undefined.
*/
embeddedMetadata: EmbeddedMetadata;
/**
* Related entity metadata.
*/
@ -205,6 +212,21 @@ export class RelationMetadata {
throw new Error(`Relation name cannot be retrieved.`);
}
/**
* Gets full path to this column property (including column property 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.
*
* @stable
*/
get propertyPath(): string {
if (!this.embeddedMetadata || !this.embeddedMetadata.parentPropertyNames.length)
return this.propertyName;
return this.embeddedMetadata.parentPropertyNames.join(".") + "." + this.propertyName;
}
/**
* Join table name.
*/
@ -212,7 +234,6 @@ export class RelationMetadata {
return this.junctionEntityMetadata.tableName;
}
/**
* Join table columns.
*/
@ -414,8 +435,41 @@ export class RelationMetadata {
* Gets given entity's relation's value.
* Using of this method helps to access value of the lazy and non-lazy relations.
*/
getEntityValue(entity: ObjectLiteral): any {
return this.isLazy ? entity["__" + this.propertyName + "__"] : entity[this.propertyName];
// getValue(entity: ObjectLiteral): any {
// return this.isLazy ? entity["__" + this.propertyName + "__"] : entity[this.propertyName];
// }
/**
* Extracts column value from the given entity.
* If column is in embedded (or recursive embedded) it extracts its value from there.
*
* @stable
*/
getEntityValue(entity: ObjectLiteral): any|undefined {
// extract column value from embeddeds of entity if column is in embedded
if (this.embeddedMetadata) {
// example: post[data][information][counters].id where "data", "information" and "counters" are embeddeds
// we need to get value of "id" column from the post real entity object
// first step - we extract all parent properties of the entity relative to this column, e.g. [data, information, counters]
const propertyNames = this.embeddedMetadata.parentPropertyNames;
// next we need to access post[data][information][counters][this.propertyName] to get column value from the counters
// this recursive function takes array of generated property names and gets the post[data][information][counters] embed
const extractEmbeddedColumnValue = (propertyNames: string[], value: ObjectLiteral): any => {
const propertyName = propertyNames.shift();
return propertyName ? extractEmbeddedColumnValue(propertyNames, value[propertyName]) : value;
};
// once we get nested embed object we get its column, e.g. post[data][information][counters][this.propertyName]
const embeddedObject = extractEmbeddedColumnValue(propertyNames, entity);
return embeddedObject ? embeddedObject[this.isLazy ? "__" + this.propertyName + "__" : this.propertyName] : undefined;
} else { // no embeds - no problems. Simply return column name by property name of the entity
return entity[this.isLazy ? "__" + this.propertyName + "__" : this.propertyName];
}
}
/**
@ -423,18 +477,31 @@ export class RelationMetadata {
* Using of this method helps to set entity relation's value of the lazy and non-lazy relations.
*/
setEntityValue(entity: ObjectLiteral, value: any): void {
if (this.isLazy) {
entity["__" + this.propertyName + "__"] = value;
} else {
entity[this.propertyName] = value;
}
}
const propertyName = this.isLazy ? "__" + this.propertyName + "__" : this.propertyName;
/**
* Checks if given entity has a value in a relation.
*/
hasEntityValue(entity: ObjectLiteral): boolean {
return this.isLazy ? entity["__" + this.propertyName + "__"] : entity[this.propertyName];
if (this.embeddedMetadata) {
// first step - we extract all parent properties of the entity relative to this column, e.g. [data, information, counters]
const extractEmbeddedColumnValue = (embeddedMetadatas: EmbeddedMetadata[], map: ObjectLiteral): any => {
// if (!object[embeddedMetadata.propertyName])
// object[embeddedMetadata.propertyName] = embeddedMetadata.create();
const embeddedMetadata = embeddedMetadatas.shift();
if (embeddedMetadata) {
if (!map[embeddedMetadata.propertyName])
map[embeddedMetadata.propertyName] = embeddedMetadata.create();
extractEmbeddedColumnValue(embeddedMetadatas, map[embeddedMetadata.propertyName]);
return map;
}
map[propertyName] = value;
return map;
};
return extractEmbeddedColumnValue(this.embeddedMetadata.embeddedMetadataTree, entity);
} else {
entity[propertyName] = value;
}
}
/**

4
src/naming-strategy/DefaultNamingStrategy.ts
View File

@ -1,6 +1,6 @@
import {NamingStrategyInterface} from "./NamingStrategyInterface";
import {RandomGenerator} from "../util/RandomGenerator";
import {snakeCase, camelCase} from "../util/StringUtils";
import {camelCase, snakeCase} from "../util/StringUtils";
/**
* Naming strategy that is used by default.
@ -42,7 +42,7 @@ export class DefaultNamingStrategy implements NamingStrategyInterface {
secondTableName: string,
firstPropertyName: string,
secondPropertyName: string): string {
return snakeCase(firstTableName + "_" + firstPropertyName + "_" + secondTableName);
return snakeCase(firstTableName + "_" + firstPropertyName.replace(/\./gi, "_") + "_" + secondTableName);
}
joinTableColumnDuplicationPrefix(columnName: string, index: number): string {

16
src/persistence/Subject.ts
View File

@ -319,8 +319,10 @@ export class Subject {
this.diffColumns = this.metadata.allColumns.filter(column => {
// prepare both entity and database values to make comparision
let entityValue = column.getEntityValue(this.entity);
let databaseValue = column.getEntityValue(this.databaseEntity);
let entityValue = column.getValue(this.entity);
let databaseValue = column.getValue(this.databaseEntity);
if (entityValue === undefined)
return false;
// normalize special values to make proper comparision
if (entityValue !== null && entityValue !== undefined) {
@ -352,12 +354,12 @@ export class Subject {
// todo: this mechanism does not get in count embeddeds in embeddeds
// if value is not defined then no need to update it
if (!column.isInEmbedded && this.entity[column.propertyName] === undefined)
return false;
// if (!column.isInEmbedded && this.entity[column.propertyName] === undefined)
// return false;
//
// if value is in embedded and is not defined then no need to update it
if (column.isInEmbedded && (this.entity[column.embeddedProperty] === undefined || this.entity[column.embeddedProperty][column.propertyName] === undefined))
return false;
// if (column.isInEmbedded && (this.entity[column.embeddedProperty] === undefined || this.entity[column.embeddedProperty][column.propertyName] === undefined))
// return false;
// if its a special column or value is not changed - then do nothing
if (column.isVirtual ||

7
src/persistence/SubjectOperationExecutor.ts
View File

@ -773,6 +773,7 @@ export class SubjectOperationExecutor {
// we group by table name, because metadata can have different table names
const valueMaps: { tableName: string, metadata: EntityMetadata, values: ObjectLiteral }[] = [];
// console.log(subject.diffColumns);
subject.diffColumns.forEach(column => {
if (!column.entityTarget) return; // todo: how this can be possible?
const metadata = this.connection.getMetadata(column.entityTarget);
@ -782,7 +783,7 @@ export class SubjectOperationExecutor {
valueMaps.push(valueMap);
}
valueMap.values[column.fullName] = this.connection.driver.preparePersistentValue(column.getEntityValue(entity), column);
valueMap.values[column.fullName] = this.connection.driver.preparePersistentValue(column.getValue(entity), column);
});
subject.diffRelations.forEach(relation => {
@ -1022,14 +1023,14 @@ export class SubjectOperationExecutor {
const secondJoinColumns = junctionRemove.relation.isOwning ? junctionRemove.relation.inverseJoinColumns : junctionRemove.relation.joinColumns;
let conditions: ObjectLiteral = {};
firstJoinColumns.forEach(joinColumn => {
conditions[joinColumn.fullName] = entity[joinColumn.referencedColumn.propertyName];
conditions[joinColumn.fullName] = joinColumn.referencedColumn.getValue(entity);
});
const removePromises = junctionRemove.junctionRelationIds.map(relationIds => {
let inverseConditions: ObjectLiteral = {};
Object.keys(relationIds).forEach(key => {
const joinColumn = secondJoinColumns.find(column => column.referencedColumn.propertyName === key);
inverseConditions[joinColumn!.fullName] = entity[joinColumn!.referencedColumn.propertyName];
inverseConditions[joinColumn!.fullName] = relationIds[key];
});
return this.queryRunner.delete(junctionMetadata.tableName, Object.assign({}, inverseConditions, conditions));
});

11
src/query-builder/JoinAttribute.ts
View File

@ -91,7 +91,7 @@ export class JoinAttribute {
if (!QueryBuilderUtils.isAliasProperty(this.entityOrProperty))
return undefined;
return this.entityOrProperty.split(".")[0];
return this.entityOrProperty.substr(0, this.entityOrProperty.indexOf("."));
}
/**
@ -101,11 +101,11 @@ export class JoinAttribute {
* This value is extracted from entityOrProperty value.
* This is available when join was made using "post.category" syntax.
*/
get relationProperty(): string|undefined {
get relationPropertyPath(): string|undefined {
if (!QueryBuilderUtils.isAliasProperty(this.entityOrProperty))
return undefined;
return this.entityOrProperty.split(".")[1];
return this.entityOrProperty.substr(this.entityOrProperty.indexOf(".") + 1);
}
/**
@ -118,9 +118,8 @@ export class JoinAttribute {
if (!QueryBuilderUtils.isAliasProperty(this.entityOrProperty))
return undefined;
const [parentAlias, relationProperty] = this.entityOrProperty.split(".");
const relationOwnerSelection = this.queryExpressionMap.findAliasByName(parentAlias);
return relationOwnerSelection.metadata.findRelationWithPropertyName(relationProperty);
const relationOwnerSelection = this.queryExpressionMap.findAliasByName(this.parentAlias!);
return relationOwnerSelection.metadata.findRelationWithPropertyPath(this.relationPropertyPath!);
}
/**

4
src/query-builder/QueryBuilder.ts
View File

@ -1628,11 +1628,11 @@ export class QueryBuilder<Entity> {
// if (metadata.hasMultiplePrimaryKeys) {
metadata.primaryColumns.forEach((primaryColumn, secondIndex) => {
whereSubStrings.push(ea(alias) + "." + ec(primaryColumn.fullName) + "=:id_" + index + "_" + secondIndex);
parameters["id_" + index + "_" + secondIndex] = primaryColumn.getEntityValue(id);
parameters["id_" + index + "_" + secondIndex] = primaryColumn.getValue(id);
});
metadata.parentIdColumns.forEach((primaryColumn, secondIndex) => {
whereSubStrings.push(ea(alias) + "." + ec(id[primaryColumn.fullName]) + "=:parentId_" + index + "_" + secondIndex);
parameters["parentId_" + index + "_" + secondIndex] = primaryColumn.getEntityValue(id);
parameters["parentId_" + index + "_" + secondIndex] = primaryColumn.getValue(id);
});
// } else {
// if (metadata.primaryColumns.length > 0) {

8
src/query-builder/relation-id/RelationIdLoader.ts
View File

@ -142,14 +142,14 @@ export class RelationIdLoader {
if (relationIdAttr.relation.isOwning) { // todo fix joinColumns[0]
joinTableColumnName = relationIdAttr.relation.joinColumns[0].referencedColumn.fullName;
inverseJoinColumnName = relationIdAttr.relation.joinColumns[0].referencedColumn.fullName;
firstJunctionColumn = relationIdAttr.relation.junctionEntityMetadata.columnsWithoutEmbeddeds[0];
secondJunctionColumn = relationIdAttr.relation.junctionEntityMetadata.columnsWithoutEmbeddeds[1];
firstJunctionColumn = relationIdAttr.relation.junctionEntityMetadata.columns[0];
secondJunctionColumn = relationIdAttr.relation.junctionEntityMetadata.columns[1];
} else {
joinTableColumnName = relationIdAttr.relation.inverseRelation.joinColumns[0].referencedColumn.fullName;
inverseJoinColumnName = relationIdAttr.relation.inverseRelation.joinColumns[0].referencedColumn.fullName;
firstJunctionColumn = relationIdAttr.relation.junctionEntityMetadata.columnsWithoutEmbeddeds[1];
secondJunctionColumn = relationIdAttr.relation.junctionEntityMetadata.columnsWithoutEmbeddeds[0];
firstJunctionColumn = relationIdAttr.relation.junctionEntityMetadata.columns[1];
secondJunctionColumn = relationIdAttr.relation.junctionEntityMetadata.columns[0];
}
const referenceColumnValues = rawEntities

35
src/query-builder/transformer/RawSqlResultsToEntityTransformer.ts
View File

@ -1,5 +1,4 @@
import {Driver} from "../../driver/Driver";
import {EmbeddedMetadata} from "../../metadata/EmbeddedMetadata";
import {RelationIdLoadResult} from "../relation-id/RelationIdLoadResult";
import {ObjectLiteral} from "../../common/ObjectLiteral";
import {ColumnMetadata} from "../../metadata/ColumnMetadata";
@ -69,14 +68,12 @@ export class RawSqlResultsToEntityTransformer {
const entity: any = alias.metadata.create();
// get value from columns selections and put them into newly created entity
hasColumns = this.transformColumns(rawResults, alias, entity, alias.metadata.columnsWithoutEmbeddeds);
hasEmbeddedColumns = this.transformEmbeddeds(rawResults, alias, entity, alias.metadata.embeddeds);
hasColumns = this.transformColumns(rawResults, alias, entity, alias.metadata.columns);
// add columns tables metadata
if (alias.metadata.parentEntityMetadata) {
hasParentColumns = this.transformColumns(rawResults, alias, entity, alias.metadata.parentEntityMetadata.columnsWithoutEmbeddeds);
hasParentEmbeddedColumns = this.transformEmbeddeds(rawResults, alias, entity, alias.metadata.parentEntityMetadata.embeddeds);
}
if (alias.metadata.parentEntityMetadata)
hasParentColumns = this.transformColumns(rawResults, alias, entity, alias.metadata.parentEntityMetadata.columns);
hasRelations = this.transformJoins(rawResults, entity, alias);
hasRelationIds = this.transformRelationIds(rawResults, alias, entity);
hasRelationCounts = this.transformRelationCounts(rawResults, alias, entity);
@ -92,29 +89,12 @@ export class RawSqlResultsToEntityTransformer {
if (value === undefined || value === null || column.isVirtual || column.isParentId || column.isDiscriminator)
return;
entity[column.propertyName] = this.driver.prepareHydratedValue(value, column);
column.setValue(entity, this.driver.prepareHydratedValue(value, column));
hasData = true;
});
return hasData;
}
protected transformEmbeddeds(rawResults: any[], alias: Alias, entity: any, embeddeds: EmbeddedMetadata[]): boolean {
let hasData = false;
embeddeds.forEach(embedded => {
const embeddedEntity = entity[embedded.propertyName] ? entity[embedded.propertyName] : embedded.create();
const hasAnyColumns = this.transformColumns(rawResults, alias, embeddedEntity, embedded.columns);
if (hasAnyColumns) {
entity[embedded.propertyName] = embeddedEntity;
hasData = true;
}
const hasInnerData = this.transformEmbeddeds(rawResults, alias, entity[embedded.propertyName], embedded.embeddeds);
if (hasInnerData)
hasData = true;
});
return hasData;
}
/**
* Transforms joined entities in the given raw results by a given alias and stores to the given (parent) entity,l
*/
@ -131,7 +111,7 @@ export class RawSqlResultsToEntityTransformer {
if (join.mapToPropertyParentAlias !== alias.name)
return;
} else {
if (!join.relation || join.parentAlias !== alias.name || join.relationProperty !== join.relation!.propertyName)
if (!join.relation || join.parentAlias !== alias.name || join.relationPropertyPath !== join.relation!.propertyPath)
return;
}
@ -143,9 +123,10 @@ export class RawSqlResultsToEntityTransformer {
// if join was mapped to some property then save result to that property
if (join.mapToPropertyPropertyName) {
entity[join.mapToPropertyPropertyName] = result;
entity[join.mapToPropertyPropertyName] = result; // todo: fix embeds
} else { // otherwise set to relation
// console.log(result);
join.relation!.setEntityValue(entity, result);
}

2
src/repository/SpecificRepository.ts
View File

@ -485,7 +485,7 @@ export class SpecificRepository<Entity extends ObjectLiteral> {
results.forEach(result => {
ids.push(Object.keys(result).reduce((id, key) => {
const junctionColumnName = inverseEntityColumns.find(joinColumn => joinColumn.name === key)!;
id[junctionColumnName.referencedColumn.name] = result[key];
id[junctionColumnName.referencedColumn.propertyName] = result[key];
return id;
}, {} as ObjectLiteral));
}); // todo: prepare result?

33
src/util/OrmUtils.ts
View File

@ -15,6 +15,33 @@ export class OrmUtils {
}, [] as Array<{ id: R, items: T[] }>);
}
static isObject(item: any) {
return (item && typeof item === "object" && !Array.isArray(item));
}
/**
* Deep Object.assign.
*
* @see http://stackoverflow.com/a/34749873
*/
static mergeDeep(target: any, ...sources: any[]): any {
if (!sources.length) return target;
const source = sources.shift();
if (this.isObject(target) && this.isObject(source)) {
for (const key in source) {
if (this.isObject(source[key])) {
if (!target[key]) Object.assign(target, { [key]: {} });
this.mergeDeep(target[key], source[key]);
} else {
Object.assign(target, { [key]: source[key] });
}
}
}
return this.mergeDeep(target, ...sources);
}
/**
* Deep compare objects.
*
@ -24,7 +51,7 @@ export class OrmUtils {
let i: any, l: any, leftChain: any, rightChain: any;
function compare2Objects(x: any, y: any) {
var p;
let p;
// remember that NaN === NaN returns false
// and isNaN(undefined) returns true
@ -118,13 +145,13 @@ export class OrmUtils {
}
if (arguments.length < 1) {
return true; //Die silently? Don't know how to handle such case, please help...
return true; // Die silently? Don't know how to handle such case, please help...
// throw "Need two or more arguments to compare";
}
for (i = 1, l = arguments.length; i < l; i++) {
leftChain = []; //Todo: this can be cached
leftChain = []; // Todo: this can be cached
rightChain = [];
if (!compare2Objects(arguments[0], arguments[i])) {

4
test/functional/decorators/relation-count/relation-count-many-to-many/relation-count-decorator-many-to-many.ts
View File

@ -1,7 +1,7 @@
import "reflect-metadata";
import * as chai from "chai";
import {expect} from "chai";
import {createTestingConnections, closeTestingConnections, reloadTestingDatabases} from "../../../../utils/test-utils";
import {closeTestingConnections, createTestingConnections, reloadTestingDatabases} from "../../../../utils/test-utils";
import {Connection} from "../../../../../src/connection/Connection";
import {Category} from "./entity/Category";
import {Post} from "./entity/Post";
@ -9,7 +9,7 @@ import {Image} from "./entity/Image";
const should = chai.should();
describe("query builder > relation-count-decorator-many-to-many > many-to-many", () => {
describe.skip("query builder > relation-count-decorator-many-to-many > many-to-many", () => {
let connections: Connection[];
before(async () => connections = await createTestingConnections({

9
test/functional/decorators/relation-id/relation-id-many-to-many/relation-id-decorator-many-to-many.ts
View File

@ -1,7 +1,7 @@
import "reflect-metadata";
import * as chai from "chai";
import {expect} from "chai";
import {createTestingConnections, closeTestingConnections, reloadTestingDatabases} from "../../../../utils/test-utils";
import {closeTestingConnections, createTestingConnections, reloadTestingDatabases} from "../../../../utils/test-utils";
import {Connection} from "../../../../../src/connection/Connection";
import {Post} from "./entity/Post";
import {Category} from "./entity/Category";
@ -174,15 +174,12 @@ describe("decorators > relation-id-decorator > many-to-many", () => {
const post1 = new Post();
post1.title = "about BMW";
post1.categories = [category];
await connection.entityManager.persist(post1);
const post2 = new Post();
post2.title = "about Audi";
post2.categories = [category];
await Promise.all([
connection.entityManager.persist(post1),
connection.entityManager.persist(post2)
]);
await connection.entityManager.persist(post2);
let loadedCategory = await connection.entityManager
.createQueryBuilder(Category, "category")

194
test/functional/embedded/embedded-many-to-many/embedded-many-to-many.ts Normal file
View File

@ -0,0 +1,194 @@
import "reflect-metadata";
import {Post} from "./entity/Post";
import {Counters} from "./entity/Counters";
import {Connection} from "../../../../src/connection/Connection";
import {expect} from "chai";
import {closeTestingConnections, createTestingConnections, reloadTestingDatabases} from "../../../utils/test-utils";
import {Subcounters} from "./entity/Subcounters";
import {User} from "./entity/User";
describe("embedded > embedded-many-to-many", () => {
let connections: Connection[];
before(async () => connections = await createTestingConnections({
entities: [__dirname + "/entity/*{.js,.ts}"],
schemaCreate: true,
dropSchemaOnConnection: true,
}));
beforeEach(() => reloadTestingDatabases(connections));
after(() => closeTestingConnections(connections));
it("should insert, load, update and remove entities with embeddeds when primary column defined only in embedded entity", () => Promise.all(connections.map(async connection => {
const user1 = new User();
user1.name = "Alice";
await connection.getRepository(User).persist(user1);
const user2 = new User();
user2.name = "Bob";
await connection.getRepository(User).persist(user2);
const user3 = new User();
user3.name = "Clara";
await connection.getRepository(User).persist(user3);
const postRepository = connection.getRepository(Post);
const post1 = new Post();
post1.title = "About cars";
post1.counters = new Counters();
post1.counters.code = 1;
post1.counters.comments = 1;
post1.counters.favorites = 2;
post1.counters.likes = 3;
post1.counters.likedUsers = [user1, user2];
post1.counters.subcounters = new Subcounters();
post1.counters.subcounters.version = 1;
post1.counters.subcounters.watches = 5;
await postRepository.persist(post1);
const post2 = new Post();
post2.title = "About airplanes";
post2.counters = new Counters();
post2.counters.code = 2;
post2.counters.comments = 2;
post2.counters.favorites = 3;
post2.counters.likes = 4;
post2.counters.likedUsers = [user3];
post2.counters.subcounters = new Subcounters();
post2.counters.subcounters.version = 1;
post2.counters.subcounters.watches = 10;
await postRepository.persist(post2);
const loadedPosts = await connection.entityManager
.createQueryBuilder(Post, "post")
.leftJoinAndSelect("post.counters.likedUsers", "likedUser")
.orderBy("post.id, likedUser.id")
.getMany();
expect(loadedPosts[0].should.be.eql(
{
id: 1,
title: "About cars",
counters: {
code: 1,
comments: 1,
favorites: 2,
likes: 3,
likedUsers: [
{
id: 1,
name: "Alice"
},
{
id: 2,
name: "Bob"
}
],
subcounters: {
version: 1,
watches: 5
}
}
}
));
expect(loadedPosts[1].should.be.eql(
{
id: 2,
title: "About airplanes",
counters: {
code: 2,
comments: 2,
favorites: 3,
likes: 4,
likedUsers: [
{
id: 3,
name: "Clara"
}
],
subcounters: {
version: 1,
watches: 10
}
}
}
));
const loadedPost = await connection.entityManager
.createQueryBuilder(Post, "post")
.leftJoinAndSelect("post.counters.likedUsers", "likedUser")
.orderBy("likedUser.id")
.where("post.id = :id", { id: 1 })
.getOne();
expect(loadedPost!.should.be.eql(
{
id: 1,
title: "About cars",
counters: {
code: 1,
comments: 1,
favorites: 2,
likes: 3,
likedUsers: [
{
id: 1,
name: "Alice"
},
{
id: 2,
name: "Bob"
}
],
subcounters: {
version: 1,
watches: 5
}
}
}
));
loadedPost!.counters.favorites += 1;
loadedPost!.counters.subcounters.watches += 1;
loadedPost!.counters.likedUsers = [user1];
await postRepository.persist(loadedPost!);
const loadedPost2 = await connection.entityManager
.createQueryBuilder(Post, "post")
.leftJoinAndSelect("post.counters.likedUsers", "likedUser")
.orderBy("likedUser.id")
.where("post.id = :id", { id: 1 })
.getOne();
expect(loadedPost2!.should.be.eql(
{
id: 1,
title: "About cars",
counters: {
code: 1,
comments: 1,
favorites: 3,
likes: 3,
likedUsers: [
{
id: 1,
name: "Alice"
}
],
subcounters: {
version: 1,
watches: 6
}
}
}
));
await postRepository.remove(loadedPost2!);
const loadedPosts2 = (await postRepository.find())!;
expect(loadedPosts2.length).to.be.equal(1);
expect(loadedPosts2[0].title).to.be.equal("About airplanes");
})));
});

31
test/functional/embedded/embedded-many-to-many/entity/Counters.ts Normal file
View File

@ -0,0 +1,31 @@
import {EmbeddableEntity} from "../../../../../src/decorator/entity/EmbeddableEntity";
import {Column} from "../../../../../src/decorator/columns/Column";
import {Embedded} from "../../../../../src/decorator/Embedded";
import {Subcounters} from "./Subcounters";
import {User} from "./User";
import {ManyToMany} from "../../../../../src/decorator/relations/ManyToMany";
import {JoinTable} from "../../../../../src/decorator/relations/JoinTable";
@EmbeddableEntity()
export class Counters {
@Column()
code: number;
@Column()
likes: number;
@Column()
comments: number;
@Column()
favorites: number;
@Embedded(() => Subcounters)
subcounters: Subcounters;
@ManyToMany(type => User)
@JoinTable()
likedUsers: User[];
}

19
test/functional/embedded/embedded-many-to-many/entity/Post.ts Normal file
View File

@ -0,0 +1,19 @@
import {Entity} from "../../../../../src/decorator/entity/Entity";
import {Column} from "../../../../../src/decorator/columns/Column";
import {Embedded} from "../../../../../src/decorator/Embedded";
import {PrimaryGeneratedColumn} from "../../../../../src/decorator/columns/PrimaryGeneratedColumn";
import {Counters} from "./Counters";
@Entity()
export class Post {
@PrimaryGeneratedColumn()
id: number;
@Column()
title: string;
@Embedded(() => Counters)
counters: Counters;
}

13
test/functional/embedded/embedded-many-to-many/entity/Subcounters.ts Normal file
View File

@ -0,0 +1,13 @@
import {EmbeddableEntity} from "../../../../../src/decorator/entity/EmbeddableEntity";
import {Column} from "../../../../../src/decorator/columns/Column";
@EmbeddableEntity()
export class Subcounters {
@Column()
version: number;
@Column()
watches: number;
}

14
test/functional/embedded/embedded-many-to-many/entity/User.ts Normal file
View File

@ -0,0 +1,14 @@
import {Column} from "../../../../../src/decorator/columns/Column";
import {PrimaryGeneratedColumn} from "../../../../../src/decorator/columns/PrimaryGeneratedColumn";
import {Entity} from "../../../../../src/decorator/entity/Entity";
@Entity()
export class User {
@PrimaryGeneratedColumn()
id: number;
@Column()
name: string;
}

2
test/functional/embedded/multiple-primary-columns-with-inherit-embed/entity/Counters.ts
View File

@ -7,7 +7,7 @@ import {Subcounters} from "./Subcounters";
@EmbeddableEntity()
export class Counters {
@PrimaryColumn({unique: true})
@PrimaryColumn()
code: number;
@Column()

2
test/functional/embedded/multiple-primary-columns-with-inherit-embed/entity/Post.ts
View File

@ -3,8 +3,10 @@ import {Column} from "../../../../../src/decorator/columns/Column";
import {Embedded} from "../../../../../src/decorator/Embedded";
import {Counters} from "./Counters";
import {PrimaryColumn} from "../../../../../src/decorator/columns/PrimaryColumn";
import {Index} from "../../../../../src/decorator/Index";
@Entity()
@Index(["id", "counters.code", "counters.subcounters.version"])
export class Post {
@PrimaryColumn()

85
test/functional/embedded/multiple-primary-columns-with-inherit-embed/multiple-primary-columns-with-inherit-embed.ts
View File

@ -3,10 +3,10 @@ import {Post} from "./entity/Post";
import {Counters} from "./entity/Counters";
import {Connection} from "../../../../src/connection/Connection";
import {expect} from "chai";
import {createTestingConnections, reloadTestingDatabases, closeTestingConnections} from "../../../utils/test-utils";
import {closeTestingConnections, createTestingConnections, reloadTestingDatabases} from "../../../utils/test-utils";
import {Subcounters} from "./entity/Subcounters";
describe.skip("embedded > multiple-primary-columns-with-inherit-embed", () => {
describe("embedded > multiple-primary-columns-with-inherit-embed", () => {
let connections: Connection[];
before(async () => connections = await createTestingConnections({
@ -52,27 +52,78 @@ describe.skip("embedded > multiple-primary-columns-with-inherit-embed", () => {
.orderBy("post.id")
.getMany();
expect(loadedPosts[0].title).to.be.equal("About cars");
expect(loadedPosts[0].counters.should.be.eql({ code: 1, comments: 1, favorites: 2, likes: 3 }));
expect(loadedPosts[0].counters.subcounters.should.be.eql({ version: 1, watches: 5 }));
expect(loadedPosts[1].title).to.be.equal("About airplanes");
expect(loadedPosts[1].counters.should.be.eql({ code: 2, comments: 2, favorites: 3, likes: 4 }));
expect(loadedPosts[1].counters.subcounters.should.be.eql({ version: 1, watches: 10 }));
expect(loadedPosts[0].should.be.eql(
{
id: 1,
title: "About cars",
counters: {
code: 1,
comments: 1,
favorites: 2,
likes: 3,
subcounters: {
version: 1,
watches: 5
}
}
}
));
expect(loadedPosts[1].should.be.eql(
{
id: 2,
title: "About airplanes",
counters: {
code: 2,
comments: 2,
favorites: 3,
likes: 4,
subcounters: {
version: 1,
watches: 10
}
}
}
));
const loadedPost = (await postRepository.findOneById(1))!;
expect(loadedPost.title).to.be.equal("About cars");
expect(loadedPost.counters.should.be.eql({ code: 1, comments: 1, favorites: 2, likes: 3 }));
expect(loadedPost.counters.subcounters.should.be.eql({ version: 1, watches: 5 }));
const loadedPost = (await postRepository.findOneById({ id: 1, counters: { code: 1, subcounters: { version: 1 } } }))!;
expect(loadedPost.should.be.eql(
{
id: 1,
title: "About cars",
counters: {
code: 1,
comments: 1,
favorites: 2,
likes: 3,
subcounters: {
version: 1,
watches: 5
}
}
}
));
loadedPost.counters.favorites += 1;
loadedPost.counters.subcounters.version += 1;
loadedPost.counters.subcounters.watches += 1;
await postRepository.persist(loadedPost);
const loadedPost2 = (await postRepository.findOneById(1))!;
expect(loadedPost.title).to.be.equal("About cars");
expect(loadedPost.counters.should.be.eql({ code: 1, comments: 1, favorites: 3, likes: 3 }));
expect(loadedPost.counters.subcounters.should.be.eql({ version: 2, watches: 6 }));
const loadedPost2 = (await postRepository.findOneById({ id: 1, counters: { code: 1, subcounters: { version: 1 } } }))!;
expect(loadedPost2.should.be.eql(
{
id: 1,
title: "About cars",
counters: {
code: 1,
comments: 1,
favorites: 3,
likes: 3,
subcounters: {
version: 1,
watches: 6
}
}
}
));
await postRepository.remove(loadedPost2);

2
test/functional/embedded/multiple-primary-columns/multiple-primary-columns.ts
View File

@ -5,7 +5,7 @@ import {Connection} from "../../../../src/connection/Connection";
import {expect} from "chai";
import {closeTestingConnections, createTestingConnections, reloadTestingDatabases} from "../../../utils/test-utils";
describe.skip("embedded > multiple-primary-column", () => {
describe("embedded > multiple-primary-column", () => {
let connections: Connection[];
before(async () => connections = await createTestingConnections({

2
test/functional/embedded/outer-primary-column/entity/Post.ts
View File

@ -12,7 +12,7 @@ export class Post {
@Column()
text: string;
@Embedded(() => Counters)
@Embedded(() => Counters, { prefix: "cnt" })
counters: Counters;
}

46
test/functional/metadata-builder/column-metadata/column-metadata.ts
View File

@ -22,7 +22,7 @@ describe("metadata-builder > ColumnMetadata", () => {
});
});
it("getEntityValue", () => Promise.all(connections.map(async connection => {
it("getValue", () => Promise.all(connections.map(async connection => {
const post = new Post();
post.title = "Post #1";
post.counters = new Counters();
@ -36,19 +36,19 @@ describe("metadata-builder > ColumnMetadata", () => {
const titleColumnMetadata = connection.getMetadata(Post).columns.find(column => column.propertyName === "title");
expect(titleColumnMetadata).not.to.be.empty;
expect(titleColumnMetadata!.getEntityValue(post)).to.be.equal("Post #1");
expect(titleColumnMetadata!.getValue(post)).to.be.equal("Post #1");
const codeColumnMetadata = connection.getMetadata(Post).columns.find(column => column.propertyName === "code");
expect(codeColumnMetadata).not.to.be.empty;
expect(codeColumnMetadata!.getEntityValue(post)).to.be.equal(123);
expect(codeColumnMetadata!.getValue(post)).to.be.equal(123);
const watchesColumnMetadata = connection.getMetadata(Post).columns.find(column => column.propertyName === "watches");
expect(watchesColumnMetadata).not.to.be.empty;
expect(watchesColumnMetadata!.getEntityValue(post)).to.be.equal(10);
expect(watchesColumnMetadata!.getValue(post)).to.be.equal(10);
})));
it("getEntityValueMap", () => Promise.all(connections.map(async connection => {
it("getValueMap", () => Promise.all(connections.map(async connection => {
const post = new Post();
post.title = "Post #1";
post.counters = new Counters();
@ -62,30 +62,30 @@ describe("metadata-builder > ColumnMetadata", () => {
const titleColumnMetadata = connection.getMetadata(Post).columns.find(column => column.propertyName === "title");
expect(titleColumnMetadata).not.to.be.empty;
expect(titleColumnMetadata!.getEntityValueMap(post)).to.be.eql({ title: "Post #1" });
expect(titleColumnMetadata!.getEntityValueMap({ id: 1 })).to.be.eql({ title: undefined }); // still not sure if it should be undefined or { title: undefined }
expect(titleColumnMetadata!.getValueMap(post)).to.be.eql({ title: "Post #1" });
expect(titleColumnMetadata!.getValueMap({ id: 1 })).to.be.eql({ title: undefined }); // still not sure if it should be undefined or { title: undefined }
const codeColumnMetadata = connection.getMetadata(Post).columns.find(column => column.propertyName === "code");
expect(codeColumnMetadata).not.to.be.empty;
expect(codeColumnMetadata!.getEntityValueMap(post)).to.be.eql({ counters: { code: 123 } });
expect(codeColumnMetadata!.getEntityValueMap({ id: 1 })).to.be.eql({ counters: { code: undefined } }); // still not sure if it should be undefined or { title: undefined }
expect(codeColumnMetadata!.getEntityValueMap({ id: 1, counters: undefined })).to.be.eql({ counters: { code: undefined } }); // still not sure if it should be undefined or { title: undefined }
expect(codeColumnMetadata!.getEntityValueMap({ id: 1, counters: { } })).to.be.eql({ counters: { code: undefined } }); // still not sure if it should be undefined or { title: undefined }
expect(codeColumnMetadata!.getEntityValueMap({ id: 1, counters: { code: undefined } })).to.be.eql({ counters: { code: undefined } }); // still not sure if it should be undefined or { title: undefined }
expect(codeColumnMetadata!.getEntityValueMap({ id: 1, counters: { code: null } })).to.be.eql({ counters: { code: null } }); // still not sure if it should be undefined or { title: undefined }
expect(codeColumnMetadata!.getEntityValueMap({ id: 1, counters: { code: 0 } })).to.be.eql({ counters: { code: 0 } }); // still not sure if it should be undefined or { title: undefined }
expect(codeColumnMetadata!.getEntityValueMap({ id: 1, counters: { likes: 123 } })).to.be.eql({ counters: { code: undefined } }); // still not sure if it should be undefined or { title: undefined }
expect(codeColumnMetadata!.getValueMap(post)).to.be.eql({ counters: { code: 123 } });
expect(codeColumnMetadata!.getValueMap({ id: 1 })).to.be.eql({ counters: { code: undefined } }); // still not sure if it should be undefined or { title: undefined }
expect(codeColumnMetadata!.getValueMap({ id: 1, counters: undefined })).to.be.eql({ counters: { code: undefined } }); // still not sure if it should be undefined or { title: undefined }
expect(codeColumnMetadata!.getValueMap({ id: 1, counters: { } })).to.be.eql({ counters: { code: undefined } }); // still not sure if it should be undefined or { title: undefined }
expect(codeColumnMetadata!.getValueMap({ id: 1, counters: { code: undefined } })).to.be.eql({ counters: { code: undefined } }); // still not sure if it should be undefined or { title: undefined }
expect(codeColumnMetadata!.getValueMap({ id: 1, counters: { code: null } })).to.be.eql({ counters: { code: null } }); // still not sure if it should be undefined or { title: undefined }
expect(codeColumnMetadata!.getValueMap({ id: 1, counters: { code: 0 } })).to.be.eql({ counters: { code: 0 } }); // still not sure if it should be undefined or { title: undefined }
expect(codeColumnMetadata!.getValueMap({ id: 1, counters: { likes: 123 } })).to.be.eql({ counters: { code: undefined } }); // still not sure if it should be undefined or { title: undefined }
const watchesColumnMetadata = connection.getMetadata(Post).columns.find(column => column.propertyName === "watches");
expect(watchesColumnMetadata).not.to.be.empty;
expect(watchesColumnMetadata!.getEntityValueMap(post)).to.be.eql({ counters: { subcounters: { watches: 10 } } });
expect(watchesColumnMetadata!.getEntityValueMap({ id: 1 })).to.be.eql({ counters: { subcounters: { watches: undefined } } }); // still not sure if it should be undefined or { title: undefined }
expect(watchesColumnMetadata!.getEntityValueMap({ id: 1, counters: undefined })).to.be.eql({ counters: { subcounters: { watches: undefined } } }); // still not sure if it should be undefined or { title: undefined }
expect(watchesColumnMetadata!.getEntityValueMap({ id: 1, counters: { } })).to.be.eql({ counters: { subcounters: { watches: undefined } } }); // still not sure if it should be undefined or { title: undefined }
expect(watchesColumnMetadata!.getEntityValueMap({ id: 1, counters: { subcounters: undefined } })).to.be.eql({ counters: { subcounters: { watches: undefined } } }); // still not sure if it should be undefined or { title: undefined }
expect(watchesColumnMetadata!.getEntityValueMap({ id: 1, counters: { subcounters: { watches: null } } })).to.be.eql({ counters: { subcounters: { watches: null } } }); // still not sure if it should be undefined or { title: undefined }
expect(watchesColumnMetadata!.getEntityValueMap({ id: 1, counters: { subcounters: { watches: 0 } } })).to.be.eql({ counters: { subcounters: { watches: 0 } } }); // still not sure if it should be undefined or { title: undefined }
expect(watchesColumnMetadata!.getEntityValueMap({ id: 1, counters: { subcounters: { version: 123 } } })).to.be.eql({ counters: { subcounters: { watches: undefined } } }); // still
expect(watchesColumnMetadata!.getValueMap(post)).to.be.eql({ counters: { subcounters: { watches: 10 } } });
expect(watchesColumnMetadata!.getValueMap({ id: 1 })).to.be.eql({ counters: { subcounters: { watches: undefined } } }); // still not sure if it should be undefined or { title: undefined }
expect(watchesColumnMetadata!.getValueMap({ id: 1, counters: undefined })).to.be.eql({ counters: { subcounters: { watches: undefined } } }); // still not sure if it should be undefined or { title: undefined }
expect(watchesColumnMetadata!.getValueMap({ id: 1, counters: { } })).to.be.eql({ counters: { subcounters: { watches: undefined } } }); // still not sure if it should be undefined or { title: undefined }
expect(watchesColumnMetadata!.getValueMap({ id: 1, counters: { subcounters: undefined } })).to.be.eql({ counters: { subcounters: { watches: undefined } } }); // still not sure if it should be undefined or { title: undefined }
expect(watchesColumnMetadata!.getValueMap({ id: 1, counters: { subcounters: { watches: null } } })).to.be.eql({ counters: { subcounters: { watches: null } } }); // still not sure if it should be undefined or { title: undefined }
expect(watchesColumnMetadata!.getValueMap({ id: 1, counters: { subcounters: { watches: 0 } } })).to.be.eql({ counters: { subcounters: { watches: 0 } } }); // still not sure if it should be undefined or { title: undefined }
expect(watchesColumnMetadata!.getValueMap({ id: 1, counters: { subcounters: { version: 123 } } })).to.be.eql({ counters: { subcounters: { watches: undefined } } }); // still
})));