f.spilla/typeorm-model-generator
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

composite primary keys support for many to many tables #30

Browse Source
This commit is contained in:
Kononnable 2018-05-05 23:57:18 +02:00
parent 5abfafe519
commit 5db68e1548
7 changed files with 544 additions and 406 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
src/drivers/AbstractDriver.ts
View File

@ -3,7 +3,6 @@ import { DatabaseModel } from "./../models/DatabaseModel";
import * as TomgUtils from "./../Utils";
import { RelationInfo } from "../models/RelationInfo";
import { ColumnInfo } from "../models/ColumnInfo";
import { ManyToMany } from "typeorm";
import {
WithWidthColumnType,
WithPrecisionColumnType,
@ -74,40 +73,48 @@ export abstract class AbstractDriver {
relations = entity.Columns.reduce((prev: RelationInfo[], curr) => {
return prev.concat(curr.relations);
}, relations);
//TODO: Composed keys
if (relations.length == 2) {
let namesOfRelatedTables = relations
.map(v => v.relatedTable)
.filter((v, i, s) => s.indexOf(v) == i);
if (namesOfRelatedTables.length == 2) {
let relatedTable1 = dbModel.entities.filter(
v => v.EntityName == relations[0].relatedTable
v => v.EntityName == namesOfRelatedTables[0]
)[0];
relatedTable1.Columns = relatedTable1.Columns.filter(
v => v.name.toLowerCase() != entity.EntityName.toLowerCase()
v =>
!v.name
.toLowerCase()
.startsWith(entity.EntityName.toLowerCase())
);
let relatedTable2 = dbModel.entities.filter(
v => v.EntityName == relations[1].relatedTable
v => v.EntityName == namesOfRelatedTables[1]
)[0];
relatedTable2.Columns = relatedTable2.Columns.filter(
v => v.name.toLowerCase() != entity.EntityName.toLowerCase()
v =>
!v.name
.toLowerCase()
.startsWith(entity.EntityName.toLowerCase())
);
dbModel.entities = dbModel.entities.filter(ent => {
return ent.EntityName != entity.EntityName;
});
let column1 = new ColumnInfo();
column1.name = relations[1].relatedTable;
column1.name = namesOfRelatedTables[1];
let col1Rel = new RelationInfo();
col1Rel.relatedTable = relations[1].relatedTable;
col1Rel.relatedColumn = relations[1].relatedTable;
col1Rel.relatedTable = namesOfRelatedTables[1];
col1Rel.relatedColumn = namesOfRelatedTables[1];
col1Rel.relationType = "ManyToMany";
col1Rel.isOwner = true;
col1Rel.ownerColumn = relations[0].relatedTable;
col1Rel.ownerColumn = namesOfRelatedTables[0];
column1.relations.push(col1Rel);
relatedTable1.Columns.push(column1);
let column2 = new ColumnInfo();
column2.name = relations[0].relatedTable;
column2.name = namesOfRelatedTables[0];
let col2Rel = new RelationInfo();
col2Rel.relatedTable = relations[0].relatedTable;
col2Rel.relatedColumn = relations[1].relatedTable;
col2Rel.relatedTable = namesOfRelatedTables[0];
col2Rel.relatedColumn = namesOfRelatedTables[1];
col2Rel.relationType = "ManyToMany";
col2Rel.isOwner = false;
column2.relations.push(col2Rel);

219
src/drivers/MssqlDriver.ts
View File

@ -378,107 +378,130 @@ order by
);
return;
}
let ownerColumn = ownerEntity.Columns.find(column => {
return column.name == relationTmp.ownerColumnsNames[0];
});
if (!ownerColumn) {
TomgUtils.LogError(
`Relation between tables ${relationTmp.ownerTable} and ${
relationTmp.referencedTable
} didn't found entity column ${
relationTmp.ownerTable
}.${ownerColumn}.`
);
return;
}
let relatedColumn = referencedEntity.Columns.find(column => {
return column.name == relationTmp.referencedColumnsNames[0];
});
if (!relatedColumn) {
TomgUtils.LogError(
`Relation between tables ${relationTmp.ownerTable} and ${
relationTmp.referencedTable
} didn't found entity column ${
relationTmp.referencedTable
}.${relatedColumn}.`
);
return;
}
let ownColumn: ColumnInfo = ownerColumn;
let isOneToMany: boolean;
isOneToMany = false;
let index = ownerEntity.Indexes.find(index => {
return (
index.isUnique &&
index.columns.some(col => {
return col.name == ownerColumn!.name;
})
);
});
if (!index) {
isOneToMany = true;
} else {
isOneToMany = false;
}
let ownerRelation = new RelationInfo();
let columnName =
ownerEntity.EntityName.toLowerCase() + (isOneToMany ? "s" : "");
if (
referencedEntity.Columns.filter(filterVal => {
return filterVal.name == columnName;
}).length > 0
for (
let relationColumnIndex = 0;
relationColumnIndex < relationTmp.ownerColumnsNames.length;
relationColumnIndex++
) {
for (let i = 2; i <= ownerEntity.Columns.length; i++) {
columnName =
ownerEntity.EntityName.toLowerCase() +
(isOneToMany ? "s" : "") +
i.toString();
if (
referencedEntity.Columns.filter(filterVal => {
return filterVal.name == columnName;
}).length == 0
)
break;
let ownerColumn = ownerEntity.Columns.find(column => {
return (
column.name ==
relationTmp.ownerColumnsNames[relationColumnIndex]
);
});
if (!ownerColumn) {
TomgUtils.LogError(
`Relation between tables ${
relationTmp.ownerTable
} and ${
relationTmp.referencedTable
} didn't found entity column ${
relationTmp.ownerTable
}.${ownerColumn}.`
);
return;
}
}
ownerRelation.actionOnDelete = relationTmp.actionOnDelete;
ownerRelation.actionOnUpdate = relationTmp.actionOnUpdate;
ownerRelation.isOwner = true;
ownerRelation.relatedColumn = relatedColumn.name.toLowerCase();
ownerRelation.relatedTable = relationTmp.referencedTable;
ownerRelation.ownerTable = relationTmp.ownerTable;
ownerRelation.ownerColumn = columnName;
ownerRelation.relationType = isOneToMany ? "ManyToOne" : "OneToOne";
ownerColumn.relations.push(ownerRelation);
if (isOneToMany) {
let col = new ColumnInfo();
col.name = columnName;
let referencedRelation = new RelationInfo();
col.relations.push(referencedRelation);
referencedRelation.actionOnDelete = relationTmp.actionOnDelete;
referencedRelation.actionOnUpdate = relationTmp.actionOnUpdate;
referencedRelation.isOwner = false;
referencedRelation.relatedColumn = ownerColumn.name;
referencedRelation.relatedTable = relationTmp.ownerTable;
referencedRelation.ownerTable = relationTmp.referencedTable;
referencedRelation.ownerColumn = relatedColumn.name.toLowerCase();
referencedRelation.relationType = "OneToMany";
referencedEntity.Columns.push(col);
} else {
let col = new ColumnInfo();
col.name = columnName;
let referencedRelation = new RelationInfo();
col.relations.push(referencedRelation);
referencedRelation.actionOnDelete = relationTmp.actionOnDelete;
referencedRelation.actionOnUpdate = relationTmp.actionOnUpdate;
referencedRelation.isOwner = false;
referencedRelation.relatedColumn = ownerColumn.name;
referencedRelation.relatedTable = relationTmp.ownerTable;
referencedRelation.ownerTable = relationTmp.referencedTable;
referencedRelation.ownerColumn = relatedColumn.name.toLowerCase();
referencedRelation.relationType = "OneToOne";
let relatedColumn = referencedEntity.Columns.find(column => {
return (
column.name ==
relationTmp.referencedColumnsNames[relationColumnIndex]
);
});
if (!relatedColumn) {
TomgUtils.LogError(
`Relation between tables ${
relationTmp.ownerTable
} and ${
relationTmp.referencedTable
} didn't found entity column ${
relationTmp.referencedTable
}.${relatedColumn}.`
);
return;
}
let ownColumn: ColumnInfo = ownerColumn;
let isOneToMany: boolean;
isOneToMany = false;
let index = ownerEntity.Indexes.find(index => {
return (
index.isUnique &&
index.columns.some(col => {
return col.name == ownerColumn!.name;
})
);
});
if (!index) {
isOneToMany = true;
} else {
isOneToMany = false;
}
let ownerRelation = new RelationInfo();
let columnName =
ownerEntity.EntityName.toLowerCase() +
(isOneToMany ? "s" : "");
if (
referencedEntity.Columns.filter(filterVal => {
return filterVal.name == columnName;
}).length > 0
) {
for (let i = 2; i <= ownerEntity.Columns.length; i++) {
columnName =
ownerEntity.EntityName.toLowerCase() +
(isOneToMany ? "s" : "") +
i.toString();
if (
referencedEntity.Columns.filter(filterVal => {
return filterVal.name == columnName;
}).length == 0
)
break;
}
}
ownerRelation.actionOnDelete = relationTmp.actionOnDelete;
ownerRelation.actionOnUpdate = relationTmp.actionOnUpdate;
ownerRelation.isOwner = true;
ownerRelation.relatedColumn = relatedColumn.name.toLowerCase();
ownerRelation.relatedTable = relationTmp.referencedTable;
ownerRelation.ownerTable = relationTmp.ownerTable;
ownerRelation.ownerColumn = columnName;
ownerRelation.relationType = isOneToMany
? "ManyToOne"
: "OneToOne";
ownerColumn.relations.push(ownerRelation);
if (isOneToMany) {
let col = new ColumnInfo();
col.name = columnName;
let referencedRelation = new RelationInfo();
col.relations.push(referencedRelation);
referencedRelation.actionOnDelete =
relationTmp.actionOnDelete;
referencedRelation.actionOnUpdate =
relationTmp.actionOnUpdate;
referencedRelation.isOwner = false;
referencedRelation.relatedColumn = ownerColumn.name;
referencedRelation.relatedTable = relationTmp.ownerTable;
referencedRelation.ownerTable = relationTmp.referencedTable;
referencedRelation.ownerColumn = relatedColumn.name.toLowerCase();
referencedRelation.relationType = "OneToMany";
referencedEntity.Columns.push(col);
} else {
let col = new ColumnInfo();
col.name = columnName;
let referencedRelation = new RelationInfo();
col.relations.push(referencedRelation);
referencedRelation.actionOnDelete =
relationTmp.actionOnDelete;
referencedRelation.actionOnUpdate =
relationTmp.actionOnUpdate;
referencedRelation.isOwner = false;
referencedRelation.relatedColumn = ownerColumn.name;
referencedRelation.relatedTable = relationTmp.ownerTable;
referencedRelation.ownerTable = relationTmp.referencedTable;
referencedRelation.ownerColumn = relatedColumn.name.toLowerCase();
referencedRelation.relationType = "OneToOne";
referencedEntity.Columns.push(col);
referencedEntity.Columns.push(col);
}
}
});
return entities;

219
src/drivers/MysqlDriver.ts
View File

@ -341,107 +341,130 @@ export class MysqlDriver extends AbstractDriver {
);
return;
}
let ownerColumn = ownerEntity.Columns.find(column => {
return column.name == relationTmp.ownerColumnsNames[0];
});
if (!ownerColumn) {
TomgUtils.LogError(
`Relation between tables ${relationTmp.ownerTable} and ${
relationTmp.referencedTable
} didn't found entity column ${
relationTmp.ownerTable
}.${ownerColumn}.`
);
return;
}
let relatedColumn = referencedEntity.Columns.find(column => {
return column.name == relationTmp.referencedColumnsNames[0];
});
if (!relatedColumn) {
TomgUtils.LogError(
`Relation between tables ${relationTmp.ownerTable} and ${
relationTmp.referencedTable
} didn't found entity column ${
relationTmp.referencedTable
}.${relatedColumn}.`
);
return;
}
let ownColumn: ColumnInfo = ownerColumn;
let isOneToMany: boolean;
isOneToMany = false;
let index = ownerEntity.Indexes.find(index => {
return (
index.isUnique &&
index.columns.some(col => {
return col.name == ownerColumn!.name;
})
);
});
if (!index) {
isOneToMany = true;
} else {
isOneToMany = false;
}
let ownerRelation = new RelationInfo();
let columnName =
ownerEntity.EntityName.toLowerCase() + (isOneToMany ? "s" : "");
if (
referencedEntity.Columns.filter(filterVal => {
return filterVal.name == columnName;
}).length > 0
for (
let relationColumnIndex = 0;
relationColumnIndex < relationTmp.ownerColumnsNames.length;
relationColumnIndex++
) {
for (let i = 2; i <= ownerEntity.Columns.length; i++) {
columnName =
ownerEntity.EntityName.toLowerCase() +
(isOneToMany ? "s" : "") +
i.toString();
if (
referencedEntity.Columns.filter(filterVal => {
return filterVal.name == columnName;
}).length == 0
)
break;
let ownerColumn = ownerEntity.Columns.find(column => {
return (
column.name ==
relationTmp.ownerColumnsNames[relationColumnIndex]
);
});
if (!ownerColumn) {
TomgUtils.LogError(
`Relation between tables ${
relationTmp.ownerTable
} and ${
relationTmp.referencedTable
} didn't found entity column ${
relationTmp.ownerTable
}.${ownerColumn}.`
);
return;
}
}
ownerRelation.actionOnDelete = relationTmp.actionOnDelete;
ownerRelation.actionOnUpdate = relationTmp.actionOnUpdate;
ownerRelation.isOwner = true;
ownerRelation.relatedColumn = relatedColumn.name.toLowerCase();
ownerRelation.relatedTable = relationTmp.referencedTable;
ownerRelation.ownerTable = relationTmp.ownerTable;
ownerRelation.ownerColumn = columnName;
ownerRelation.relationType = isOneToMany ? "ManyToOne" : "OneToOne";
ownerColumn.relations.push(ownerRelation);
if (isOneToMany) {
let col = new ColumnInfo();
col.name = columnName;
let referencedRelation = new RelationInfo();
col.relations.push(referencedRelation);
referencedRelation.actionOnDelete = relationTmp.actionOnDelete;
referencedRelation.actionOnUpdate = relationTmp.actionOnUpdate;
referencedRelation.isOwner = false;
referencedRelation.relatedColumn = ownerColumn.name;
referencedRelation.relatedTable = relationTmp.ownerTable;
referencedRelation.ownerTable = relationTmp.referencedTable;
referencedRelation.ownerColumn = relatedColumn.name.toLowerCase();
referencedRelation.relationType = "OneToMany";
referencedEntity.Columns.push(col);
} else {
let col = new ColumnInfo();
col.name = columnName;
let referencedRelation = new RelationInfo();
col.relations.push(referencedRelation);
referencedRelation.actionOnDelete = relationTmp.actionOnDelete;
referencedRelation.actionOnUpdate = relationTmp.actionOnUpdate;
referencedRelation.isOwner = false;
referencedRelation.relatedColumn = ownerColumn.name;
referencedRelation.relatedTable = relationTmp.ownerTable;
referencedRelation.ownerTable = relationTmp.referencedTable;
referencedRelation.ownerColumn = relatedColumn.name.toLowerCase();
referencedRelation.relationType = "OneToOne";
let relatedColumn = referencedEntity.Columns.find(column => {
return (
column.name ==
relationTmp.referencedColumnsNames[relationColumnIndex]
);
});
if (!relatedColumn) {
TomgUtils.LogError(
`Relation between tables ${
relationTmp.ownerTable
} and ${
relationTmp.referencedTable
} didn't found entity column ${
relationTmp.referencedTable
}.${relatedColumn}.`
);
return;
}
let ownColumn: ColumnInfo = ownerColumn;
let isOneToMany: boolean;
isOneToMany = false;
let index = ownerEntity.Indexes.find(index => {
return (
index.isUnique &&
index.columns.some(col => {
return col.name == ownerColumn!.name;
})
);
});
if (!index) {
isOneToMany = true;
} else {
isOneToMany = false;
}
let ownerRelation = new RelationInfo();
let columnName =
ownerEntity.EntityName.toLowerCase() +
(isOneToMany ? "s" : "");
if (
referencedEntity.Columns.filter(filterVal => {
return filterVal.name == columnName;
}).length > 0
) {
for (let i = 2; i <= ownerEntity.Columns.length; i++) {
columnName =
ownerEntity.EntityName.toLowerCase() +
(isOneToMany ? "s" : "") +
i.toString();
if (
referencedEntity.Columns.filter(filterVal => {
return filterVal.name == columnName;
}).length == 0
)
break;
}
}
ownerRelation.actionOnDelete = relationTmp.actionOnDelete;
ownerRelation.actionOnUpdate = relationTmp.actionOnUpdate;
ownerRelation.isOwner = true;
ownerRelation.relatedColumn = relatedColumn.name.toLowerCase();
ownerRelation.relatedTable = relationTmp.referencedTable;
ownerRelation.ownerTable = relationTmp.ownerTable;
ownerRelation.ownerColumn = columnName;
ownerRelation.relationType = isOneToMany
? "ManyToOne"
: "OneToOne";
ownerColumn.relations.push(ownerRelation);
if (isOneToMany) {
let col = new ColumnInfo();
col.name = columnName;
let referencedRelation = new RelationInfo();
col.relations.push(referencedRelation);
referencedRelation.actionOnDelete =
relationTmp.actionOnDelete;
referencedRelation.actionOnUpdate =
relationTmp.actionOnUpdate;
referencedRelation.isOwner = false;
referencedRelation.relatedColumn = ownerColumn.name;
referencedRelation.relatedTable = relationTmp.ownerTable;
referencedRelation.ownerTable = relationTmp.referencedTable;
referencedRelation.ownerColumn = relatedColumn.name.toLowerCase();
referencedRelation.relationType = "OneToMany";
referencedEntity.Columns.push(col);
} else {
let col = new ColumnInfo();
col.name = columnName;
let referencedRelation = new RelationInfo();
col.relations.push(referencedRelation);
referencedRelation.actionOnDelete =
relationTmp.actionOnDelete;
referencedRelation.actionOnUpdate =
relationTmp.actionOnUpdate;
referencedRelation.isOwner = false;
referencedRelation.relatedColumn = ownerColumn.name;
referencedRelation.relatedTable = relationTmp.ownerTable;
referencedRelation.ownerTable = relationTmp.referencedTable;
referencedRelation.ownerColumn = relatedColumn.name.toLowerCase();
referencedRelation.relationType = "OneToOne";
referencedEntity.Columns.push(col);
referencedEntity.Columns.push(col);
}
}
});
return entities;

219
src/drivers/OracleDriver.ts
View File

@ -307,107 +307,130 @@ export class OracleDriver extends AbstractDriver {
);
return;
}
let ownerColumn = ownerEntity.Columns.find(column => {
return column.name == relationTmp.ownerColumnsNames[0];
});
if (!ownerColumn) {
TomgUtils.LogError(
`Relation between tables ${relationTmp.ownerTable} and ${
relationTmp.referencedTable
} didn't found entity column ${
relationTmp.ownerTable
}.${ownerColumn}.`
);
return;
}
let relatedColumn = referencedEntity.Columns.find(column => {
return column.name == relationTmp.referencedColumnsNames[0];
});
if (!relatedColumn) {
TomgUtils.LogError(
`Relation between tables ${relationTmp.ownerTable} and ${
relationTmp.referencedTable
} didn't found entity column ${
relationTmp.referencedTable
}.${relatedColumn}.`
);
return;
}
let ownColumn: ColumnInfo = ownerColumn;
let isOneToMany: boolean;
isOneToMany = false;
let index = ownerEntity.Indexes.find(index => {
return (
index.isUnique &&
index.columns.some(col => {
return col.name == ownerColumn!.name;
})
);
});
if (!index) {
isOneToMany = true;
} else {
isOneToMany = false;
}
let ownerRelation = new RelationInfo();
let columnName =
ownerEntity.EntityName.toLowerCase() + (isOneToMany ? "s" : "");
if (
referencedEntity.Columns.filter(filterVal => {
return filterVal.name == columnName;
}).length > 0
for (
let relationColumnIndex = 0;
relationColumnIndex < relationTmp.ownerColumnsNames.length;
relationColumnIndex++
) {
for (let i = 2; i <= ownerEntity.Columns.length; i++) {
columnName =
ownerEntity.EntityName.toLowerCase() +
(isOneToMany ? "s" : "") +
i.toString();
if (
referencedEntity.Columns.filter(filterVal => {
return filterVal.name == columnName;
}).length == 0
)
break;
let ownerColumn = ownerEntity.Columns.find(column => {
return (
column.name ==
relationTmp.ownerColumnsNames[relationColumnIndex]
);
});
if (!ownerColumn) {
TomgUtils.LogError(
`Relation between tables ${
relationTmp.ownerTable
} and ${
relationTmp.referencedTable
} didn't found entity column ${
relationTmp.ownerTable
}.${ownerColumn}.`
);
return;
}
}
ownerRelation.actionOnDelete = relationTmp.actionOnDelete;
ownerRelation.actionOnUpdate = relationTmp.actionOnUpdate;
ownerRelation.isOwner = true;
ownerRelation.relatedColumn = relatedColumn.name.toLowerCase();
ownerRelation.relatedTable = relationTmp.referencedTable;
ownerRelation.ownerTable = relationTmp.ownerTable;
ownerRelation.ownerColumn = columnName;
ownerRelation.relationType = isOneToMany ? "ManyToOne" : "OneToOne";
ownerColumn.relations.push(ownerRelation);
if (isOneToMany) {
let col = new ColumnInfo();
col.name = columnName;
let referencedRelation = new RelationInfo();
col.relations.push(referencedRelation);
referencedRelation.actionOnDelete = relationTmp.actionOnDelete;
referencedRelation.actionOnUpdate = relationTmp.actionOnUpdate;
referencedRelation.isOwner = false;
referencedRelation.relatedColumn = ownerColumn.name;
referencedRelation.relatedTable = relationTmp.ownerTable;
referencedRelation.ownerTable = relationTmp.referencedTable;
referencedRelation.ownerColumn = relatedColumn.name.toLowerCase();
referencedRelation.relationType = "OneToMany";
referencedEntity.Columns.push(col);
} else {
let col = new ColumnInfo();
col.name = columnName;
let referencedRelation = new RelationInfo();
col.relations.push(referencedRelation);
referencedRelation.actionOnDelete = relationTmp.actionOnDelete;
referencedRelation.actionOnUpdate = relationTmp.actionOnUpdate;
referencedRelation.isOwner = false;
referencedRelation.relatedColumn = ownerColumn.name;
referencedRelation.relatedTable = relationTmp.ownerTable;
referencedRelation.ownerTable = relationTmp.referencedTable;
referencedRelation.ownerColumn = relatedColumn.name.toLowerCase();
referencedRelation.relationType = "OneToOne";
let relatedColumn = referencedEntity.Columns.find(column => {
return (
column.name ==
relationTmp.referencedColumnsNames[relationColumnIndex]
);
});
if (!relatedColumn) {
TomgUtils.LogError(
`Relation between tables ${
relationTmp.ownerTable
} and ${
relationTmp.referencedTable
} didn't found entity column ${
relationTmp.referencedTable
}.${relatedColumn}.`
);
return;
}
let ownColumn: ColumnInfo = ownerColumn;
let isOneToMany: boolean;
isOneToMany = false;
let index = ownerEntity.Indexes.find(index => {
return (
index.isUnique &&
index.columns.some(col => {
return col.name == ownerColumn!.name;
})
);
});
if (!index) {
isOneToMany = true;
} else {
isOneToMany = false;
}
let ownerRelation = new RelationInfo();
let columnName =
ownerEntity.EntityName.toLowerCase() +
(isOneToMany ? "s" : "");
if (
referencedEntity.Columns.filter(filterVal => {
return filterVal.name == columnName;
}).length > 0
) {
for (let i = 2; i <= ownerEntity.Columns.length; i++) {
columnName =
ownerEntity.EntityName.toLowerCase() +
(isOneToMany ? "s" : "") +
i.toString();
if (
referencedEntity.Columns.filter(filterVal => {
return filterVal.name == columnName;
}).length == 0
)
break;
}
}
ownerRelation.actionOnDelete = relationTmp.actionOnDelete;
ownerRelation.actionOnUpdate = relationTmp.actionOnUpdate;
ownerRelation.isOwner = true;
ownerRelation.relatedColumn = relatedColumn.name.toLowerCase();
ownerRelation.relatedTable = relationTmp.referencedTable;
ownerRelation.ownerTable = relationTmp.ownerTable;
ownerRelation.ownerColumn = columnName;
ownerRelation.relationType = isOneToMany
? "ManyToOne"
: "OneToOne";
ownerColumn.relations.push(ownerRelation);
if (isOneToMany) {
let col = new ColumnInfo();
col.name = columnName;
let referencedRelation = new RelationInfo();
col.relations.push(referencedRelation);
referencedRelation.actionOnDelete =
relationTmp.actionOnDelete;
referencedRelation.actionOnUpdate =
relationTmp.actionOnUpdate;
referencedRelation.isOwner = false;
referencedRelation.relatedColumn = ownerColumn.name;
referencedRelation.relatedTable = relationTmp.ownerTable;
referencedRelation.ownerTable = relationTmp.referencedTable;
referencedRelation.ownerColumn = relatedColumn.name.toLowerCase();
referencedRelation.relationType = "OneToMany";
referencedEntity.Columns.push(col);
} else {
let col = new ColumnInfo();
col.name = columnName;
let referencedRelation = new RelationInfo();
col.relations.push(referencedRelation);
referencedRelation.actionOnDelete =
relationTmp.actionOnDelete;
referencedRelation.actionOnUpdate =
relationTmp.actionOnUpdate;
referencedRelation.isOwner = false;
referencedRelation.relatedColumn = ownerColumn.name;
referencedRelation.relatedTable = relationTmp.ownerTable;
referencedRelation.ownerTable = relationTmp.referencedTable;
referencedRelation.ownerColumn = relatedColumn.name.toLowerCase();
referencedRelation.relationType = "OneToOne";
referencedEntity.Columns.push(col);
referencedEntity.Columns.push(col);
}
}
});
return entities;

219
src/drivers/PostgresDriver.ts
View File

@ -470,107 +470,130 @@ export class PostgresDriver extends AbstractDriver {
);
return;
}
let ownerColumn = ownerEntity.Columns.find(column => {
return column.name == relationTmp.ownerColumnsNames[0];
});
if (!ownerColumn) {
TomgUtils.LogError(
`Relation between tables ${relationTmp.ownerTable} and ${
relationTmp.referencedTable
} didn't found entity column ${
relationTmp.ownerTable
}.${ownerColumn}.`
);
return;
}
let relatedColumn = referencedEntity.Columns.find(column => {
return column.name == relationTmp.referencedColumnsNames[0];
});
if (!relatedColumn) {
TomgUtils.LogError(
`Relation between tables ${relationTmp.ownerTable} and ${
relationTmp.referencedTable
} didn't found entity column ${
relationTmp.referencedTable
}.${relatedColumn}.`
);
return;
}
let ownColumn: ColumnInfo = ownerColumn;
let isOneToMany: boolean;
isOneToMany = false;
let index = ownerEntity.Indexes.find(index => {
return (
index.isUnique &&
index.columns.some(col => {
return col.name == ownerColumn!.name;
})
);
});
if (!index) {
isOneToMany = true;
} else {
isOneToMany = false;
}
let ownerRelation = new RelationInfo();
let columnName =
ownerEntity.EntityName.toLowerCase() + (isOneToMany ? "s" : "");
if (
referencedEntity.Columns.filter(filterVal => {
return filterVal.name == columnName;
}).length > 0
for (
let relationColumnIndex = 0;
relationColumnIndex < relationTmp.ownerColumnsNames.length;
relationColumnIndex++
) {
for (let i = 2; i <= ownerEntity.Columns.length; i++) {
columnName =
ownerEntity.EntityName.toLowerCase() +
(isOneToMany ? "s" : "") +
i.toString();
if (
referencedEntity.Columns.filter(filterVal => {
return filterVal.name == columnName;
}).length == 0
)
break;
let ownerColumn = ownerEntity.Columns.find(column => {
return (
column.name ==
relationTmp.ownerColumnsNames[relationColumnIndex]
);
});
if (!ownerColumn) {
TomgUtils.LogError(
`Relation between tables ${
relationTmp.ownerTable
} and ${
relationTmp.referencedTable
} didn't found entity column ${
relationTmp.ownerTable
}.${ownerColumn}.`
);
return;
}
}
ownerRelation.actionOnDelete = relationTmp.actionOnDelete;
ownerRelation.actionOnUpdate = relationTmp.actionOnUpdate;
ownerRelation.isOwner = true;
ownerRelation.relatedColumn = relatedColumn.name.toLowerCase();
ownerRelation.relatedTable = relationTmp.referencedTable;
ownerRelation.ownerTable = relationTmp.ownerTable;
ownerRelation.ownerColumn = columnName;
ownerRelation.relationType = isOneToMany ? "ManyToOne" : "OneToOne";
ownerColumn.relations.push(ownerRelation);
if (isOneToMany) {
let col = new ColumnInfo();
col.name = columnName;
let referencedRelation = new RelationInfo();
col.relations.push(referencedRelation);
referencedRelation.actionondelete = relationTmp.actionOnDelete;
referencedRelation.actiononupdate = relationTmp.actionOnUpdate;
referencedRelation.isOwner = false;
referencedRelation.relatedColumn = ownerColumn.name;
referencedRelation.relatedTable = relationTmp.ownerTable;
referencedRelation.ownerTable = relationTmp.referencedTable;
referencedRelation.ownerColumn = relatedColumn.name.toLowerCase();
referencedRelation.relationType = "OneToMany";
referencedEntity.Columns.push(col);
} else {
let col = new ColumnInfo();
col.name = columnName;
let referencedRelation = new RelationInfo();
col.relations.push(referencedRelation);
referencedRelation.actionondelete = relationTmp.actionOnDelete;
referencedRelation.actiononupdate = relationTmp.actionOnUpdate;
referencedRelation.isOwner = false;
referencedRelation.relatedColumn = ownerColumn.name;
referencedRelation.relatedTable = relationTmp.ownerTable;
referencedRelation.ownerTable = relationTmp.referencedTable;
referencedRelation.ownerColumn = relatedColumn.name.toLowerCase();
referencedRelation.relationType = "OneToOne";
let relatedColumn = referencedEntity.Columns.find(column => {
return (
column.name ==
relationTmp.referencedColumnsNames[relationColumnIndex]
);
});
if (!relatedColumn) {
TomgUtils.LogError(
`Relation between tables ${
relationTmp.ownerTable
} and ${
relationTmp.referencedTable
} didn't found entity column ${
relationTmp.referencedTable
}.${relatedColumn}.`
);
return;
}
let ownColumn: ColumnInfo = ownerColumn;
let isOneToMany: boolean;
isOneToMany = false;
let index = ownerEntity.Indexes.find(index => {
return (
index.isUnique &&
index.columns.some(col => {
return col.name == ownerColumn!.name;
})
);
});
if (!index) {
isOneToMany = true;
} else {
isOneToMany = false;
}
let ownerRelation = new RelationInfo();
let columnName =
ownerEntity.EntityName.toLowerCase() +
(isOneToMany ? "s" : "");
if (
referencedEntity.Columns.filter(filterVal => {
return filterVal.name == columnName;
}).length > 0
) {
for (let i = 2; i <= ownerEntity.Columns.length; i++) {
columnName =
ownerEntity.EntityName.toLowerCase() +
(isOneToMany ? "s" : "") +
i.toString();
if (
referencedEntity.Columns.filter(filterVal => {
return filterVal.name == columnName;
}).length == 0
)
break;
}
}
ownerRelation.actionOnDelete = relationTmp.actionOnDelete;
ownerRelation.actionOnUpdate = relationTmp.actionOnUpdate;
ownerRelation.isOwner = true;
ownerRelation.relatedColumn = relatedColumn.name.toLowerCase();
ownerRelation.relatedTable = relationTmp.referencedTable;
ownerRelation.ownerTable = relationTmp.ownerTable;
ownerRelation.ownerColumn = columnName;
ownerRelation.relationType = isOneToMany
? "ManyToOne"
: "OneToOne";
ownerColumn.relations.push(ownerRelation);
if (isOneToMany) {
let col = new ColumnInfo();
col.name = columnName;
let referencedRelation = new RelationInfo();
col.relations.push(referencedRelation);
referencedRelation.actionondelete =
relationTmp.actionOnDelete;
referencedRelation.actiononupdate =
relationTmp.actionOnUpdate;
referencedRelation.isOwner = false;
referencedRelation.relatedColumn = ownerColumn.name;
referencedRelation.relatedTable = relationTmp.ownerTable;
referencedRelation.ownerTable = relationTmp.referencedTable;
referencedRelation.ownerColumn = relatedColumn.name.toLowerCase();
referencedRelation.relationType = "OneToMany";
referencedEntity.Columns.push(col);
} else {
let col = new ColumnInfo();
col.name = columnName;
let referencedRelation = new RelationInfo();
col.relations.push(referencedRelation);
referencedRelation.actionondelete =
relationTmp.actionOnDelete;
referencedRelation.actiononupdate =
relationTmp.actionOnUpdate;
referencedRelation.isOwner = false;
referencedRelation.relatedColumn = ownerColumn.name;
referencedRelation.relatedTable = relationTmp.ownerTable;
referencedRelation.ownerTable = relationTmp.referencedTable;
referencedRelation.ownerColumn = relatedColumn.name.toLowerCase();
referencedRelation.relationType = "OneToOne";
referencedEntity.Columns.push(col);
referencedEntity.Columns.push(col);
}
}
});
return entities;

18
test/integration/examples/sample4_2-many-to-many_composite_keys/entity/Post.ts Normal file
View File

@ -0,0 +1,18 @@
import { PrimaryColumn, Column, Entity, OneToOne, OneToMany, ManyToOne, ManyToMany, JoinColumn, JoinTable } from "typeorm";
import {PostAuthor} from "./PostAuthor";
@Entity("Post")
export class Post {
@PrimaryColumn("int")
id: number;
@PrimaryColumn()
type: string;
// post has relation with details. not cascades here. means cannot be persisted, updated or removed
@ManyToMany(type => PostAuthor, author => author.Post)
@JoinTable()
PostAuthor: PostAuthor[];
}

21
test/integration/examples/sample4_2-many-to-many_composite_keys/entity/PostAuthor.ts Normal file
View File

@ -0,0 +1,21 @@
import { PrimaryColumn, Column, Entity, OneToOne, OneToMany, ManyToOne, ManyToMany, JoinColumn, JoinTable } from "typeorm";
import {Post} from "./Post";
@Entity("PostAuthor")
export class PostAuthor {
@PrimaryColumn("int")
id: number;
@PrimaryColumn()
type: string;
@Column()
name: string;
@ManyToMany(type => Post, post => post.PostAuthor)
Post: Post[];
}