zibri 2.4.0 → 2.4.1

package/src/data-source/nested-where-filter.test.ts

@@ -0,0 +1,344 @@
+/* eslint-disable unicorn/no-null */
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from '@jest/globals';
+
+import { createTestDataSource, defaultTestServerEntities } from '../__testing__/test-server/create-test-data-source.function';
+import { startTestServer, StartedTestServer } from '../__testing__/test-server/start-test-server.function';
+import { WhereFilter } from '../data-source/models/where/where-filter.model';
+import { Repository } from '../data-source/repository';
+import { repositoryTokenFor } from '../di/decorators/inject-repository.decorator';
+import { inject } from '../di/inject.function';
+import { BaseEntity } from '../entity/base-entity.model';
+import { Entity } from '../entity/decorators/entity.decorator';
+import { Property } from '../entity/decorators/property.decorator';
+
+// ---------- Entity definitions for deeply nested structure ----------
+class Address {
+    @Property.string()
+    street!: string;
+
+    @Property.string()
+    city!: string;
+
+    @Property.string({ required: false })
+    type?: string; // 'home', 'work', etc.
+}
+
+class PersonalData {
+    @Property.string()
+    favoriteColor!: string;
+
+    @Property.number()
+    height!: number;
+
+    @Property.array({ items: { type: 'object', cls: () => Address }, required: false })
+    addresses: Address[] | undefined | null;
+}
+
+@Entity()
+class Customer extends BaseEntity {
+    @Property.string()
+    name!: string;
+
+    @Property.object({ cls: () => PersonalData, required: false })
+    personalData: PersonalData | undefined | null;
+
+    @Property.string({ required: false })
+    notes: string | null | undefined;
+}
+
+class Tag {
+    @Property.string()
+    key!: string;
+
+    @Property.string()
+    value!: string;
+}
+
+class Item {
+    @Property.string()
+    name!: string;
+
+    @Property.array({ items: { type: 'object', cls: () => Tag }, required: false })
+    tags: Tag[] | undefined | null;
+}
+
+@Entity()
+class Container extends BaseEntity {
+    @Property.string()
+    title!: string;
+
+    @Property.array({ items: { type: 'object', cls: () => Item }, required: false })
+    items: Item[] | undefined | null;
+}
+
+let server: StartedTestServer;
+let customerRepo: Repository<Customer>;
+
+beforeAll(async () => {
+    server = await startTestServer({
+        dataSources: [
+            createTestDataSource({
+                entities: [...defaultTestServerEntities, Customer, Container]
+            })
+        ]
+    });
+    customerRepo = inject(repositoryTokenFor(Customer));
+}, 15000);
+
+afterAll(async () => {
+    await server.shutdown();
+});
+
+beforeEach(async () => {
+    await customerRepo.deleteAll({});
+});
+
+// Seed helpers
+async function seedCustomers(...data: Partial<Customer>[]): Promise<Customer[]> {
+    return Promise.all(data.map(d => customerRepo.create(d)));
+}
+
+describe('Where filters – deeply nested (object → array → object)', () => {
+    let alice: Customer;
+    let bob: Customer;
+
+    beforeEach(async () => {
+        [alice, bob] = await seedCustomers(
+            {
+                name: 'Alice',
+                personalData: {
+                    favoriteColor: 'blue',
+                    height: 165,
+                    addresses: [
+                        { street: '123 Main St', city: 'Springfield', type: 'home' },
+                        { street: '456 Work Ave', city: 'Springfield', type: 'work' }
+                    ]
+                }
+            },
+            {
+                name: 'Bob',
+                personalData: {
+                    favoriteColor: 'red',
+                    height: 180,
+                    // eslint-disable-next-line cspell/spellchecker
+                    addresses: [{ street: '789 Oak Rd', city: 'Shelbyville', type: 'home' }]
+                }
+            }
+        );
+    });
+
+    // ===== Top-level simple field =====
+    it('top-level string equals', async () => {
+        const res: Customer[] = await customerRepo.findAll({ where: { name: 'Alice' } });
+        expect(res.map(c => c.id)).toEqual([alice.id]);
+    });
+
+    // ===== Nested object (PersonalData) =====
+    it('nested object field equals', async () => {
+        const res: Customer[] = await customerRepo.findAll({
+            where: { personalData: { where: { favoriteColor: 'blue' } } }
+        });
+        expect(res.map(c => c.id)).toEqual([alice.id]);
+    });
+
+    it('nested object field not equal', async () => {
+        const res: Customer[] = await customerRepo.findAll({
+            where: { personalData: { where: { favoriteColor: { not: 'blue' } } } }
+        });
+        expect(res.map(c => c.id)).toEqual([bob.id]);
+    });
+
+    it('nested object field oneOf', async () => {
+        const res: Customer[] = await customerRepo.findAll({
+            where: { personalData: { where: { favoriteColor: { oneOf: ['blue', 'green'] } } } }
+        });
+        expect(res.map(c => c.id)).toEqual([alice.id]);
+    });
+
+    it('nested object field greaterThan on number', async () => {
+        const res: Customer[] = await customerRepo.findAll({
+            where: { personalData: { where: { height: { greaterThan: 170 } } } }
+        });
+        expect(res.map(c => c.id)).toEqual([bob.id]);
+    });
+
+    // ===== Array of objects (Addresses) exact match =====
+    it('exact array match (shorthand)', async () => {
+        // Works due to recent fix: plain array = exact match via @> & <@
+        const res: Customer[] = await customerRepo.findAll({
+            where: {
+                personalData: {
+                    where: {
+                        addresses: [
+                            { street: '123 Main St', city: 'Springfield', type: 'home' },
+                            { street: '456 Work Ave', city: 'Springfield', type: 'work' }
+                        ]
+                    }
+                }
+            }
+        });
+        expect(res.map(c => c.id)).toEqual([alice.id]);
+    });
+
+    // ===== Array of objects: includes (contains) – requires feature, skip for now =====
+    it('array includes (contains all specified objects)', async () => {
+        // TODO: implement partial object match in includes for object arrays
+        const res: Customer[] = await customerRepo.findAll({
+            where: {
+                personalData: {
+                    where: {
+                        addresses: { includes: [{ street: '123 Main St', city: 'Springfield' }] }
+                    }
+                }
+            }
+        });
+        expect(res.map(c => c.id)).toEqual([alice.id]);
+    });
+
+    // ===== Array of objects: nested where on items (if supported) =====
+    it('array item where filter', async () => {
+        // TODO: implement 'where' on array items to filter by item properties
+        const res: Customer[] = await customerRepo.findAll({
+            where: {
+                personalData: {
+                    where: {
+                        addresses: { where: { street: '456 Work Ave' } }
+                    }
+                }
+            }
+        });
+        expect(res.map(c => c.id)).toEqual([alice.id]);
+    });
+
+    // ===== Array size / null =====
+    it('array is null', async () => {
+        await customerRepo.updateById(alice.id, { personalData: { ...alice.personalData, addresses: null } });
+        const res: Customer[] = await customerRepo.findAll({
+            where: { personalData: { where: { addresses: null } } }
+        });
+        expect(res.map(c => c.id)).toEqual([alice.id]);
+    });
+
+    // ===== Entire nested object is null =====
+    it('nested object is null', async () => {
+        await customerRepo.updateById(bob.id, { personalData: null });
+        const res: Customer[] = await customerRepo.findAll({
+            where: { personalData: { is: null } }
+        });
+        expect(res.map(c => c.id)).toEqual([bob.id]);
+    });
+
+    // ===== OR combination with nested filters =====
+    it('OR with nested object conditions', async () => {
+        const filters: WhereFilter<Customer>[] = [
+            { personalData: { where: { favoriteColor: 'blue' } } },
+            { personalData: { where: { height: 180 } } }
+        ];
+        const res: Customer[] = await customerRepo.findAll({ where: filters });
+        expect(res.map(c => c.id).sort()).toEqual([alice.id, bob.id].sort());
+    });
+
+    // ===== Array of objects with nested array of objects =====
+    describe('Container with Item → Tag (array → object → array)', () => {
+        let container: Container;
+        let container2: Container;
+        let containerRepo: Repository<Container>;
+
+        beforeAll(() => {
+            containerRepo = inject(repositoryTokenFor(Container));
+        });
+
+        beforeEach(async () => {
+            await containerRepo.deleteAll({});
+            [container, container2] = await Promise.all([
+                containerRepo.create({
+                    title: 'Container A',
+                    items: [
+                        {
+                            name: 'Item 1',
+                            tags: [
+                                { key: 'color', value: 'red' },
+                                { key: 'size', value: 'large' }
+                            ]
+                        },
+                        {
+                            name: 'Item 2',
+                            tags: [{ key: 'color', value: 'blue' }]
+                        }
+                    ]
+                }),
+                containerRepo.create({
+                    title: 'Container B',
+                    items: [
+                        {
+                            name: 'Item 3',
+                            tags: [{ key: 'color', value: 'green' }]
+                        }
+                    ]
+                })
+            ]);
+        });
+
+        it('filters by nested array of objects using where on array', async () => {
+        // Find containers that have an item with a tag where key = 'size'
+            const res: Container[] = await containerRepo.findAll({
+                where: {
+                    items: {
+                        where: {
+                            tags: {
+                                where: { key: 'size' }
+                            }
+                        }
+                    }
+                }
+            });
+            expect(res.map(c => c.id)).toEqual([container.id]);
+        });
+
+        it('filters by nested array of objects using includes', async () => {
+        // Find containers that have an item that includes both specified tags (exact object match)
+            const res: Container[] = await containerRepo.findAll({
+                where: {
+                    items: {
+                        where: {
+                            tags: {
+                                includes: [{ key: 'color', value: 'red' }, { key: 'size', value: 'large' }]
+                            }
+                        }
+                    }
+                }
+            });
+            expect(res.map(c => c.id)).toEqual([container.id]);
+        });
+
+        it('filters by nested array of objects using isIncludedIn', async () => {
+            // Container A's Item 2 tags is a subset of the given list
+            const res: Container[] = await containerRepo.findAll({
+                where: {
+                    items: {
+                        where: {
+                            tags: {
+                                isIncludedIn: [{ key: 'color', value: 'blue' }, { key: 'extra', value: 'something' }]
+                            }
+                        }
+                    }
+                }
+            });
+            expect(res.map(c => c.id)).toEqual([container.id]);
+        });
+
+        it('filters by exact array match on nested array', async () => {
+        // Find containers where an item has exactly the tags [{ key: 'color', value: 'green' }]
+            const res: Container[] = await containerRepo.findAll({
+                where: {
+                    items: {
+                        where: {
+                            tags: [{ key: 'color', value: 'green' }]
+                        }
+                    }
+                }
+            });
+            expect(res.map(c => c.id)).toEqual([container2.id]);
+        });
+    });
+});

package/src/data-source/query-failed.error.ts

@@ -25,8 +25,45 @@ function buildErrorMessage(error: TOQueryFailedError): string {
         query = `${parts[0]}\nVALUES ${parts[1]}`;
     }
 
+    let message: string = error.message;
+    if (
+        message.includes('duplicate key value violates unique constraint')
+        && 'detail' in error.driverError
+        && typeof error.driverError.detail === 'string'
+    ) {
+        const key: string = error.driverError.detail.split('Key (').at(1)
+            ?.split(')=')
+            .at(0) ?? '';
+        message = message.replace(
+            'duplicate key value violates unique constraint',
+            `duplicate value for property "${key}" violates unique constraint`
+        );
+    }
+    if (
+        message.includes('violates foreign key constraint')
+        && 'detail' in error.driverError
+        && typeof error.driverError.detail === 'string'
+    ) {
+        const detail: string = error.driverError.detail;
+        // Example: "Key (id)=(a1b2c3d4-...) is still referenced from table "user_groups_group"."
+        const keyMatch: RegExpMatchArray | null = detail.match(/Key \((.+?)\)=\((.+?)\)/);
+        const tableMatch: RegExpMatchArray | null = detail.match(/table "(.+?)"/);
+        if (keyMatch && tableMatch) {
+            const key: string = keyMatch[1];
+            const value: string = keyMatch[2];
+            const referencingTable: string = tableMatch[1];
+            message = message.replace(
+                'violates foreign key constraint',
+                [
+                    'violates foreign key constraint:',
+                    `cannot delete or update because ${referencingTable}.${key} still references this row (value = ${value})`
+                ].join('\n')
+            );
+        }
+    }
+
     return [
-        error.message,
+        message,
         'SQL:',
         query
     ].join('\n');

package/src/data-source/repository-relation-pitfalls.test.ts

@@ -0,0 +1,232 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from '@jest/globals';
+import { type Relation } from 'typeorm';
+
+import { Repository } from './repository';
+import { createTestDataSource, defaultTestServerEntities } from '../__testing__/test-server/create-test-data-source.function';
+import { startTestServer, StartedTestServer } from '../__testing__/test-server/start-test-server.function';
+import { repositoryTokenFor } from '../di/decorators/inject-repository.decorator';
+import { inject } from '../di/inject.function';
+import { BaseEntity } from '../entity/base-entity.model';
+import { Entity } from '../entity/decorators/entity.decorator';
+import { Property } from '../entity/decorators/property.decorator';
+
+// ==================== ENTITIES ====================
+
+@Entity()
+class Parent extends BaseEntity {
+    @Property.string()
+    name!: string;
+
+    @Property.oneToMany({ target: () => Child, inverseSide: 'parent' })
+    children!: Child[];
+}
+
+@Entity()
+class Child extends BaseEntity {
+    @Property.string()
+    name!: string;
+
+    @Property.manyToOne({ target: () => Parent, inverseSide: 'children', joinColumn: 'parentId' })
+    parent!: Parent;
+
+    @Property.string({ format: 'uuid' })
+    parentId!: string;
+}
+
+@Entity()
+class Author extends BaseEntity {
+    @Property.string()
+    name!: string;
+
+    // Non-owning side (joinTable: false)
+    @Property.manyToMany({ target: () => Book, inverseSide: 'authors', joinTable: false })
+    books!: Book[];
+}
+
+@Entity()
+class Book extends BaseEntity { // redeclare to add inverse (real code would be in one place)
+    @Property.string()
+    title!: string;
+
+    // Owning side (joinTable: true)
+    @Property.manyToMany({ target: () => Author, inverseSide: 'books', joinTable: true })
+    authors!: Author[];
+}
+
+@Entity()
+class Reader extends BaseEntity {
+    @Property.string()
+    name!: string;
+
+    @Property.hasOne({ target: () => Bookmark, inverseSide: 'reader' })
+    bookmark!: Relation<Bookmark>;
+}
+
+@Entity()
+class Bookmark extends BaseEntity {
+    @Property.string()
+    page!: string;
+
+    @Property.belongsToOne({ target: () => Reader, inverseSide: 'bookmark', joinColumn: 'readerId' })
+    reader!: Reader;
+
+    @Property.string({ format: 'uuid' })
+    readerId!: string;
+}
+
+// ==================== TEST ====================
+
+let server: StartedTestServer;
+let authorRepo: Repository<Author>;
+let bookRepo: Repository<Book>;
+let readerRepo: Repository<Reader>;
+let bookmarkRepo: Repository<Bookmark>;
+let parentRepo: Repository<Parent>;
+let childRepo: Repository<Child>;
+
+beforeAll(async () => {
+    server = await startTestServer({
+        dataSources: [
+            createTestDataSource({
+                entities: [...defaultTestServerEntities, Author, Book, Reader, Bookmark, Parent, Child]
+            })
+        ]
+    });
+    authorRepo = inject(repositoryTokenFor(Author));
+    bookRepo = inject(repositoryTokenFor(Book));
+    readerRepo = inject(repositoryTokenFor(Reader));
+    bookmarkRepo = inject(repositoryTokenFor(Bookmark));
+    parentRepo = inject(repositoryTokenFor(Parent));
+    childRepo = inject(repositoryTokenFor(Child));
+}, 15000);
+
+afterAll(async () => {
+    await server.shutdown();
+});
+
+beforeEach(async () => {
+    await bookmarkRepo.deleteAll({});
+    await readerRepo.deleteAll({});
+    await bookRepo.deleteAll({});
+    await authorRepo.deleteAll({});
+    await parentRepo.deleteAll({});
+    await childRepo.deleteAll({});
+});
+
+// ==================== TESTS ====================
+
+describe('Repository relation pitfalls', () => {
+
+    describe('many-to-many assignment from non-owning side', () => {
+        it('should NOT silently ignore assignment on inverse side', async () => {
+            const author: Author = await authorRepo.create({ name: 'Jane' });
+            const book1: Book = await bookRepo.create({ title: 'Book 1' });
+            const book2: Book = await bookRepo.create({ title: 'Book 2' });
+
+            // Assign books from the NON-OWNING side (Author.books)
+            await authorRepo.updateById(author.id, { books: [book1, book2] });
+
+            // Re-fetch with relations to see if the junction table was updated
+            const fetchedAuthor: Author = await authorRepo.findById(author.id, { relations: ['books'] });
+            expect(fetchedAuthor.books.length).toBe(2); // ❌ will FAIL currently – proves the bug
+        });
+    });
+
+    describe('updateAll – existing many-to-many relations data leak', () => {
+        it('should replace old relations, not leave them dangling', async () => {
+            const author: Author = await authorRepo.create({ name: 'Mark' });
+            const book1: Book = await bookRepo.create({ title: 'Old' });
+            const book2: Book = await bookRepo.create({ title: 'New' });
+
+            // Assign initial books (owning side, works correctly)
+            await bookRepo.updateById(book1.id, { authors: [author] });
+            await bookRepo.updateById(book2.id, { authors: [author] });
+
+            // Verify author has both books
+            const before: Author = await authorRepo.findById(author.id, { relations: ['books'] });
+            expect(before.books.length).toBe(2);
+
+            // Now use updateAll to set only book2 (should remove book1)
+            await authorRepo.updateAll({ id: author.id }, { books: [book2] });
+
+            const after: Author = await authorRepo.findById(author.id, { relations: ['books'] });
+            expect(after.books.length).toBe(1); // ❌ will FAIL if data leak exists
+            expect(after.books[0].id).toBe(book2.id);
+        });
+    });
+
+    describe('hasOne – assignment on inverse side ignored', () => {
+        it('should not silently ignore assignment on hasOne side', async () => {
+            const reader: Reader = await readerRepo.create({ name: 'Alice' });
+            const bookmark: Bookmark = await bookmarkRepo.create({ page: 'p42', readerId: reader.id });
+
+            // Attempt to set reader.bookmark from the non-owning side
+            await readerRepo.updateById(reader.id, { bookmark: bookmark });
+
+            const fetched: Reader = await readerRepo.findById(reader.id, { relations: ['bookmark'] });
+            expect(fetched.bookmark).not.toBeNull(); // ❌ will FAIL currently – proves the bug
+            expect(fetched.bookmark.id).toBe(bookmark.id);
+        });
+    });
+
+    describe('deleting owning side (Book) should cascade to junction table', () => {
+        it('removes the junction rows, author sees empty books', async () => {
+            const author: Author = await authorRepo.create({ name: 'Orwell' });
+            const book: Book = await bookRepo.create({ title: '1984', authors: [author] });
+
+            await bookRepo.deleteById(book.id);
+
+            const fetchedAuthor: Author = await authorRepo.findById(author.id, { relations: ['books'] });
+            expect(fetchedAuthor.books.length).toBe(0); // junction rows removed
+        });
+    });
+
+    describe('deleting inverse side (Author) without manual detach', () => {
+        it('should either succeed (clean cascade) or throw FK violation (known limitation)', async () => {
+            const author: Author = await authorRepo.create({ name: 'Hemingway' });
+            const book: Book = await bookRepo.create({ title: 'Old Man', authors: [author] });
+
+            // Deleting the author — TypeORM cleans up the junction table automatically
+            await authorRepo.deleteById(author.id);
+
+            // The book still exists …
+            const fetchedBook: Book = await bookRepo.findById(book.id, { relations: ['authors'] });
+            expect(fetchedBook).toBeDefined();
+            // … but its authors array is now empty (junction rows deleted)
+            expect(fetchedBook.authors.length).toBe(0);
+        });
+    });
+
+    describe('one-to-many / many-to-one deletion', () => {
+        let parent: Parent;
+        let child1: Child;
+        let child2: Child;
+
+        beforeEach(async () => {
+            parent = await parentRepo.create({ name: 'Parent' });
+            child1 = await childRepo.create({ name: 'Child 1', parentId: parent.id });
+            child2 = await childRepo.create({ name: 'Child 2', parentId: parent.id });
+        });
+
+        it('deleting the parent cascades and removes children', async () => {
+            await parentRepo.deleteById(parent.id);
+
+            // Both children should be gone
+            const found1: Child | undefined = await childRepo.findOne({ where: { id: child1.id } }, false);
+            const found2: Child | undefined = await childRepo.findOne({ where: { id: child2.id } }, false);
+            expect(found1).toBeUndefined();
+            expect(found2).toBeUndefined();
+        });
+
+        it('deleting a child does NOT delete the parent or other children', async () => {
+            await childRepo.deleteById(child1.id);
+
+            const parentAfter: Parent = await parentRepo.findById(parent.id, { relations: ['children'] });
+            expect(parentAfter.children).toHaveLength(1);
+            expect(parentAfter.children[0].id).toBe(child2.id);
+
+            const deletedChild: Child | undefined = await childRepo.findOne({ where: { id: child1.id } }, false);
+            expect(deletedChild).toBeUndefined();
+        });
+    });
+});