ORM for TypeScript and JavaScript. Supports MySQL, PostgreSQL, MariaDB, SQLite, MS SQL Server, Oracle, SAP Hana, WebSQL databases. Works in NodeJS, Browser, Ionic, Cordova and Electron platforms.
MIT License
Bot releases are hidden (Show)
Published by pleerock over 2 years ago
Changes in the version includes changes from the next
branch and typeorm@next
version.
They were pending their migration from 2018. Finally, they are in the master branch and master version.
compilation target
now is es2020
. This requires Node.JS version 14+
TypeORM now properly works when installed within different node_modules contexts
(often happen if TypeORM is a dependency of another library or TypeORM is heavily used in monorepo projects)
Connection
was renamed to DataSource
.
Old Connection
is still there, but now it's deprecated. It will be completely removed in next version.
New API:
export const dataSource = new DataSource({
// ... options ...
})
// load entities, establish db connection, sync schema, etc.
await dataSource.connect()
Previously, you could use new Connection()
, createConnection()
, getConnectionManager().create()
, etc.
They all deprecated in favour of new syntax you can see above.
New way gives you more flexibility and simplicity in usage.
export const UserRepository = myDataSource.getRepository(UserEntity).extend({
findUsersWithPhotos() {
return this.find({
relations: {
photos: true
}
})
}
})
Old ways of custom repository creation were dropped.
added new option on relation load strategy called relationLoadStrategy
.
Relation load strategy is used on entity load and determines how relations must be loaded when you query entities and their relations from the database.
Used on find*
methods and QueryBuilder
. Value can be set to join
or query
.
join
- loads relations using SQL JOIN
expressionquery
- executes separate SQL queries for each relationDefault is join
, but default can be set in ConnectionOptions
:
createConnection({
/* ... */
relationLoadStrategy: "query"
})
Also, it can be set per-query in find*
methods:
userRepository.find({
relations: {
photos: true
}
})
And QueryBuilder:
userRepository
.createQueryBuilder()
.setRelationLoadStrategy("query")
For queries returning big amount of data, we recommend to use query
strategy,
because it can be a more performant approach to query relations.
findOneBy
, findOneByOrFail
, findBy
, countBy
, findAndCountBy
methods to BaseEntity
, EntityManager
and Repository
:const users = await userRepository.findBy({
name: "Michael"
})
Overall find*
and count*
method signatures where changed, read the "breaking changes" section for more info.
select
type signature in FindOptions
(used in find*
methods):userRepository.find({
select: {
id: true,
firstName: true,
lastName: true,
}
})
Also, now it's possible to specify select columns of the loaded relations:
userRepository.find({
select: {
id: true,
firstName: true,
lastName: true,
photo: {
id: true,
filename: true,
album: {
id: true,
name: true,
}
}
}
})
relations
type signature in FindOptions
(used in find*
methods):userRepository.find({
relations: {
contacts: true,
photos: true,
}
})
To load nested relations use a following signature:
userRepository.find({
relations: {
contacts: true,
photos: {
album: true,
},
}
})
order
type signature in FindOptions
(used in find*
methods):userRepository.find({
order: {
id: "ASC"
}
})
Now supports nested order by-s:
userRepository.find({
order: {
photos: {
album: {
name: "ASC"
},
},
}
})
where
type signature in FindOptions
(used in find*
methods) now allows to build nested statements with conditional relations, for example:userRepository.find({
where: {
photos: {
album: {
name: "profile"
}
}
}
})
Gives you users who have photos in their "profile" album.
FindOperator
-s can be applied for relations in where
statement, for example:userRepository.find({
where: {
photos: MoreThan(10),
}
})
Gives you users with more than 10 photos.
boolean
can be applied for relations in where
statement, for example:userRepository.find({
where: {
photos: true
}
})
minimal Node.JS version requirement now is 14+
drop ormconfig
support. ormconfig
still works if you use deprecated methods,
however we do not recommend using it anymore, because it's support will be completely dropped in 0.4.0
.
If you want to have your connection options defined in a separate file, you can still do it like this:
import ormconfig from "./ormconfig.json"
const MyDataSource = new DataSource(require("./ormconfig.json"))
Or even more type-safe approach with resolveJsonModule
in tsconfig.json
enabled:
import ormconfig from "./ormconfig.json"
const MyDataSource = new DataSource(ormconfig)
But we do not recommend use this practice, because from 0.4.0
you'll only be able to specify entities / subscribers / migrations using direct references to entity classes / schemas (see "deprecations" section).
We won't be supporting all ormconfig
extensions (e.g. json
, js
, ts
, yaml
, xml
, env
).
support for previously deprecated migrations:*
commands was removed. Use migration:*
commands instead.
all commands were re-worked. Please refer to new CLI documentation.
cli
option from BaseConnectionOptions
(now BaseDataSourceOptions
options) was removed (since CLI commands were re-worked).
now migrations are running before schema synchronization if you have both pending migrations and schema synchronization pending
(it works if you have both migrationsRun
and synchronize
enabled in connection options).
aurora-data-api
driver now is called aurora-mysql
aurora-data-api-pg
driver now is called aurora-postgres
EntityManager.connection
is now EntityManager.dataSource
Repository
now has a constructor (breaks classes extending Repository with custom constructor)
@TransactionRepository
, @TransactionManager
, @Transaction
decorators were completely removed. These decorators do the things out of the TypeORM scope.
Only junction table names shortened.
MOTIVATION: We must shorten only table names generated by TypeORM.
It's user responsibility to name tables short if their RDBMS limit table name length
since it won't make sense to have table names as random hashes.
It's really better if user specify custom table name into @Entity
decorator.
Also, for junction table it's possible to set a custom name using @JoinTable
decorator.
findOne()
signature without parameters was dropped.const [user] = await userRepository.find()
This change was made to prevent user confusion.
See this issue for details.
findOne(id)
signature was dropped. Use following syntax instead:const user = await userRepository.findOneBy({
id: id // where id is your column name
})
This change was made to provide a more type-safe approach for data querying.
Due to this change you might need to refactor the way you load entities using MongoDB driver.
findOne
, findOneOrFail
, find
, count
, findAndCount
methods now only accept FindOptions
as parameter, e.g.:const users = await userRepository.find({
where: { /* conditions */ },
relations: { /* relations */ }
})
To supply where
conditions directly without FindOptions
new methods were added:
findOneBy
, findOneByOrFail
, findBy
, countBy
, findAndCountBy
. Example:
const users = await userRepository.findBy({
name: "Michael"
})
This change was required to simply current find*
and count*
methods typings,
improve type safety and prevent user confusion.
findByIds
was deprecated, use findBy
method instead in conjunction with In
operator, for example:userRepository.findBy({
id: In([1, 2, 3])
})
This change was made to provide a more type-safe approach for data querying.
findOne
and QueryBuilder.getOne()
now return null
instead of undefined
in the case if it didn't find anything in the database.
Logically it makes more sense to return null
.
findOne
now limits returning rows to 1 at database level.
NOTE: FOR UPDATE
locking does not work with findOne
in Oracle since FOR UPDATE
cannot be used with FETCH NEXT
in a single query.
where
in FindOptions
(e.g. find({ where: { ... })
) is more sensitive to input criteria now.
FindConditions
(where
in FindOptions
) was renamed to FindOptionsWhere
.
null
as value in where
used in find*
methods is not supported anymore.
Now you must explicitly use IsNull()
operator.
Before:
userRepository.find({
where: {
photo: null
}
})
After:
userRepository.find({
where: {
photo: IsNull()
}
})
This change was made to make it more transparent on how to add "IS NULL" statement to final SQL,
because before it bring too much confusion for ORM users.
find*
's where
. Example:Before for the @Column(/*...*/) membership: MembershipKind
you could have a query like:
userRepository.find({
membership: new MembershipKind("premium")
})
now, you need to wrap this value into Equal
operator:
userRepository.find({
membership: Equal(new MembershipKind("premium"))
})
This change is due to type-safety improvement new where
signature brings.
order
in FindOptions
(used in find*
methods) doesn't support ordering by relations anymore.
Define relation columns, and order by them instead.
where
in FindOptions
(used in find*
methods) previously supported ObjectLiteral
and string
types.
Now both signatures were removed. ObjectLiteral was removed because it seriously breaks the type safety,
and string
doesn't make sense in the context of FindOptions
. Use QueryBuilder
instead.
MongoRepository
and MongoEntityManager
now use new types called MongoFindManyOptions
and MongoFindOneOptions
for their find*
methods.
primary relation
(e.g. @ManyToOne(() => User, { primary: true }) user: User
) support is removed.
You still have an ability to use foreign keys as your primary keys,
however now you must explicitly define a column marked as primary.
Example, before:
@ManyToOne(() => User, { primary: true })
user: User
Now:
@PrimaryColumn()
userId: number
@ManyToOne(() => User)
user: User
Primary column name must match the relation name + join column name on related entity.
If related entity has multiple primary keys, and you want to point to multiple primary keys,
you can define multiple primary columns the same way:
@PrimaryColumn()
userFirstName: string
@PrimaryColumn()
userLastName: string
@ManyToOne(() => User)
user: User
This change was required to simplify ORM internals and introduce new features.
prefix relation id columns contained in embedded entities (#7432)
find by Date object in sqlite driver (#7538)
issue with non-reliable new Date(ISOString)
parsing (#7796)
all CLI commands do not support ormconfig
anymore. You must specify a file with data source instance instead.
entities
, migrations
, subscribers
options inside DataSourceOptions
accepting string
directories support is deprecated.
You'll be only able to pass entity references in the future versions.
all container-related features (UseContainerOptions
, ContainedType
, ContainerInterface
, defaultContainer
,
useContainer
, getFromContainer
) are deprecated.
EntityManager's getCustomRepository
used within transactions is deprecated. Use withRepository
method instead.
Connection.isConnected
is deprecated. Use .isInitialized
instead.
select
in FindOptions
(used in find*
methods) used as an array of property names is deprecated.
Now you should use a new object-literal notation. Example:
Deprecated way of loading entity relations:
userRepository.find({
select: ["id", "firstName", "lastName"]
})
New way of loading entity relations:
userRepository.find({
select: {
id: true,
firstName: true,
lastName: true,
}
})
This change is due to type-safety improvement new select
signature brings.
relations
in FindOptions
(used in find*
methods) used as an array of relation names is deprecated.Deprecated way of loading entity relations:
userRepository.find({
relations: ["contacts", "photos", "photos.album"]
})
New way of loading entity relations:
userRepository.find({
relations: {
contacts: true,
photos: {
album: true
}
}
})
This change is due to type-safety improvement new relations
signature brings.
join
in FindOptions
(used in find*
methods) is deprecated. Use QueryBuilder
to build queries containing manual joins.
Connection
, ConnectionOptions
are deprecated, new names to use are: DataSource
and DataSourceOptions
.
To create the same connection you had before use a new syntax: new DataSource({ /*...*/ })
.
createConnection()
, createConnections()
are deprecated, since Connection
is called DataSource
now, to create a connection and connect to the database
simply do:
const myDataSource = new DataSource({ /*...*/ })
await myDataSource.connect()
getConnection()
is deprecated. To have a globally accessible connection, simply export your data source and use it in places you need it:export const myDataSource = new DataSource({ /*...*/ })
// now you can use myDataSource anywhere in your application
getManager()
, getMongoManager()
, getSqljsManager()
, getRepository()
, getTreeRepository()
, getMongoRepository()
, createQueryBuilder()
export const myDataSource = new DataSource({ /*...*/ })
export const Manager = myDataSource.manager
export const UserRepository = myDataSource.getRepository(UserEntity)
export const PhotoRepository = myDataSource.getRepository(PhotoEntity)
// ...
getConnectionManager()
and ConnectionManager
itself are deprecated - now Connection
is called DataSource
,const dataSource1 = new DataSource({ /*...*/ })
const dataSource2 = new DataSource({ /*...*/ })
const dataSource3 = new DataSource({ /*...*/ })
export const MyDataSources = {
dataSource1,
dataSource2,
dataSource3,
}
getConnectionOptions()
is deprecated - in next version we are going to implement different mechanism of connection options loading
AbstractRepository
is deprecated. Use new way of custom repositories creation.
Connection.name
and BaseConnectionOptions.name
are deprecated. Connections don't need names anymore since we are going to drop all related methods relying on this property.
all deprecated signatures will be removed in 0.4.0
observers
- we will consider returning them back with new API in future versionsalternative find operators
- using $any
, $in
, $like
and other operators in where
condition.Published by pleerock over 2 years ago
Published by pleerock over 2 years ago
Published by pleerock over 2 years ago
uuid
library (#8642) (8898a71)update: false
columns shouldn't trigger @UpdateDateColumn column updation (2834729), closes #8394 #8394 #8394
Published by pleerock almost 3 years ago
retryWrites
to MongoConnectionOptions
(#8354) (c895680), closes #7869
UNIQUE
constraints detection (#8364) (29cb891), closes #8158
Published by pleerock almost 3 years ago
Published by pleerock almost 3 years ago
typeorm
command wrapper to package.json in project template (#8081) (19d4a91)Published by imnotjames about 3 years ago
connections
property should include list of Connection
s (#8004) (2344db6)Published by imnotjames about 3 years ago
WhereExpression
alias for WhereExpressionBuilder
(#7980) (76e7ed9)browser
package manifests (#7982) (0d90bcd)Published by imnotjames about 3 years ago
entity
to be Partial<Entity>
| undefined
in UpdateEvent
(#7783) (f033045)prepare
per Hana client docs (#7748) (8ca05b1)afterUpdate
subscriber (#7724) (d25304d)OracleQueryRunner
createDatabase if-not-exists not fail (f5a80ef)data
from SaveOptions during that query (#7886) (1de2e13)join
conditions undefined
-able (#7892) (b0c1cc6)buildColumnAlias
for backward compatibility (#7706) (36ceefa)Entity
(#7910) (78fbc14)retryWrites
to allowed mongo extra
options (#7869) (dcdaaca)entitySkipConstructor
(f43d561)extras
for mongodb (#7801) (90894c7)Transaction*Event
types (#7949) (2436a66), closes /github.com/typeorm/typeorm/blob/master/src/subscriber/EntitySubscriberInterface.ts#L12
enableArithAbort
for SQLServerDriver (#7894) (1f64da2)