import { MikroORM, defineEntity, p, Opt } from '@mikro-orm/sqlite'; // Define schemas without classes - auto-generated classes will be created const AuthorSchema = defineEntity({ name: 'Author', properties: { id: p.integer().primary(), firstName: p.string(), lastName: p.string(), books: () => p.oneToMany(Book).mappedBy('author'), }, }); const BookSchema = defineEntity({ name: 'Book', properties: { id: p.integer().primary(), title: p.string(), author: () => p.manyToOne(Author), }, }); // Extend the auto-generated classes to add custom methods class Author extends AuthorSchema.class { fullName() { return `${this.firstName} ${this.lastName}`; } get initials(): Opt & string { return `${this.firstName[0]}.${this.lastName[0]}.`; } } class Book extends BookSchema.class { get summary(): Opt & string { return `"${this.title}" by ${this.author.fullName()}`; } } // Register the custom classes - this must happen before MikroORM.init() AuthorSchema.setClass(Author); BookSchema.setClass(Book); describe('defineEntity with setClass (SQLite)', () => { let orm: MikroORM; beforeAll(async () => { orm = await MikroORM.init({ entities: [AuthorSchema, BookSchema], dbName: ':memory:', }); await orm.schema.create(); }); afterAll(() => orm.close(true)); beforeEach(async () => { await orm.schema.clear(); }); test('em.create() returns instance of custom class with methods', async () => { const author = orm.em.create(Author, { firstName: 'John', lastName: 'Doe', }); expect(author).toBeInstanceOf(Author); expect(author.fullName()).toBe('John Doe'); expect(author.initials).toBe('J.D.'); }); test('entities can be persisted and loaded with custom methods intact', async () => { const author = orm.em.create(Author, { firstName: 'Jane', lastName: 'Smith', }); await orm.em.flush(); orm.em.clear(); const loadedAuthor = await orm.em.findOneOrFail(Author, author.id); expect(loadedAuthor).toBeInstanceOf(Author); expect(loadedAuthor.fullName()).toBe('Jane Smith'); expect(loadedAuthor.initials).toBe('J.S.'); }); test('relations work correctly with extended classes', async () => { const author = orm.em.create(Author, { firstName: 'Alice', lastName: 'Brown', }); const book = orm.em.create(Book, { title: 'My First Book', author, }); await orm.em.flush(); orm.em.clear(); const loadedBook = await orm.em.findOneOrFail(Book, book.id, { populate: ['author'], }); expect(loadedBook).toBeInstanceOf(Book); expect(loadedBook.author).toBeInstanceOf(Author); expect(loadedBook.summary).toBe('"My First Book" by Alice Brown'); }); test('can use extended class in queries', async () => { orm.em.create(Author, { firstName: 'Test1', lastName: 'Author1' }); orm.em.create(Author, { firstName: 'Test2', lastName: 'Author2' }); await orm.em.flush(); orm.em.clear(); const authors = await orm.em.find(Author, {}); expect(authors).toHaveLength(2); expect(authors[0]).toBeInstanceOf(Author); expect(authors[0].fullName()).toBe('Test1 Author1'); expect(authors[1].fullName()).toBe('Test2 Author2'); }); test('getReference returns instance of extended class', async () => { const author = orm.em.create(Author, { firstName: 'Ref', lastName: 'Test', }); await orm.em.flush(); orm.em.clear(); const ref = orm.em.getReference(Author, author.id); expect(ref).toBeInstanceOf(Author); await orm.em.findOneOrFail(Author, author.id); expect(ref.fullName()).toBe('Ref Test'); }); test('collections contain instances of extended class', async () => { const author = orm.em.create(Author, { firstName: 'Collection', lastName: 'Test', }); orm.em.create(Book, { title: 'Book 1', author }); orm.em.create(Book, { title: 'Book 2', author }); await orm.em.flush(); orm.em.clear(); const loadedAuthor = await orm.em.findOneOrFail(Author, author.id, { populate: ['books'], }); expect(loadedAuthor.books).toHaveLength(2); for (const book of loadedAuthor.books) { expect(book).toBeInstanceOf(Book); } }); test('entity name different from class name does not cause duplicates (GH #7391)', async () => { // When defineEntity name differs from the class name, discovery should // not treat the auto-generated parent class as a separate entity. const TagSchema = defineEntity({ name: 'TagEntity', properties: { id: p.integer().primary(), label: p.string(), }, }); class Tag extends TagSchema.class {} TagSchema.setClass(Tag); const testOrm = await MikroORM.init({ entities: [Tag], dbName: ':memory:', }); const metadata = [...testOrm.getMetadata().getAll().values()]; expect(metadata).toHaveLength(1); expect(metadata[0].className).toBe('TagEntity'); expect(metadata[0].class).toBe(Tag); await testOrm.schema.create(); testOrm.em.create(Tag, { label: 'test' }); await testOrm.em.flush(); testOrm.em.clear(); const tag = await testOrm.em.findOneOrFail(Tag, { label: 'test' }); expect(tag).toBeInstanceOf(Tag); expect(tag.label).toBe('test'); await testOrm.close(true); }); });