mongodb-dynamic-api 3.2.1 → 4.1.0

package/test/dynamic-api-for-feature.e2e-spec.js

@@ -1,1100 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const mongoose_1 = require("@nestjs/mongoose");
-const testing_1 = require("@nestjs/testing");
-const mongoose_2 = require("mongoose");
-const src_1 = require("../src");
-const e2e_setup_1 = require("./e2e.setup");
-require("dotenv/config");
-const utils_1 = require("./utils");
-describe('DynamicApiModule forFeature (e2e)', () => {
-    const uri = process.env.MONGO_DB_URL;
-    const initApp = async (forFeatureOptions, forRootOptions = {}, initFixtures, initMainCb, testGateway) => {
-        const moduleRef = await testing_1.Test.createTestingModule({
-            imports: [
-                src_1.DynamicApiModule.forRoot(uri, forRootOptions),
-                src_1.DynamicApiModule.forFeature(forFeatureOptions),
-            ],
-            providers: testGateway ? [e2e_setup_1.TestGateway] : [],
-        }).compile();
-        await (0, e2e_setup_1.createTestingApp)(moduleRef, initFixtures, initMainCb);
-    };
-    beforeEach(() => {
-        src_1.DynamicApiModule.state['resetState']();
-    });
-    afterEach(async () => {
-        await (0, e2e_setup_1.closeTestingApp)(mongoose_2.default.connections);
-    });
-    describe('Entity extends BaseEntity', () => {
-        let TestEntity = class TestEntity extends src_1.BaseEntity {
-        };
-        __decorate([
-            (0, mongoose_1.Prop)({ type: String, required: true }),
-            __metadata("design:type", String)
-        ], TestEntity.prototype, "name", void 0);
-        __decorate([
-            (0, mongoose_1.Prop)({ type: String }),
-            __metadata("design:type", String)
-        ], TestEntity.prototype, "group", void 0);
-        TestEntity = __decorate([
-            (0, src_1.DynamicAPISchemaOptions)({
-                indexes: [{ fields: { name: 1 }, options: { unique: true } }],
-            }),
-            (0, mongoose_1.Schema)({ collection: 'test-entities' })
-        ], TestEntity);
-        beforeEach(async () => {
-            const fixtures = async (_) => {
-                const model = await (0, utils_1.getModelFromEntity)(TestEntity);
-                await model.insertMany([
-                    { name: 'test1' },
-                    { name: 'test2' },
-                ]);
-            };
-            await initApp({
-                entity: TestEntity,
-                controllerOptions: {
-                    path: 'test-entities',
-                },
-            }, {}, fixtures);
-        });
-        describe('GET /test-entities', () => {
-            it('should return all test entities', async () => {
-                const { body, status } = await e2e_setup_1.server.get('/test-entities');
-                expect(status).toBe(200);
-                expect(body).toEqual([
-                    {
-                        id: expect.any(String),
-                        name: 'test1',
-                        createdAt: expect.any(String),
-                        updatedAt: expect.any(String),
-                    },
-                    {
-                        id: expect.any(String),
-                        name: 'test2',
-                        createdAt: expect.any(String),
-                        updatedAt: expect.any(String),
-                    },
-                ]);
-            });
-        });
-        describe('GET /test-entities/:id', () => {
-            let entities;
-            beforeEach(async () => {
-                const { body } = await e2e_setup_1.server.get('/test-entities');
-                entities = body;
-            });
-            it('should return a test entity by id', async () => {
-                const { body, status } = await e2e_setup_1.server.get(`/test-entities/${entities[0].id}`);
-                expect(status).toBe(200);
-                expect(body).toEqual(entities[0]);
-            });
-            it('should return 404 if entity not found', async () => {
-                const { body, status } = await e2e_setup_1.server.get(`/test-entities/123`);
-                expect(status).toBe(404);
-                expect(body).toHaveProperty('error', 'Not Found');
-                expect(body).toHaveProperty('statusCode', 404);
-                expect(body).toHaveProperty('message', 'TestEntity not found');
-            });
-        });
-        describe('POST /test-entities/many', () => {
-            it('should create many test entities', async () => {
-                const { body, status } = await e2e_setup_1.server.post('/test-entities/many', {
-                    list: [
-                        { name: 'test3' },
-                        { name: 'test4' },
-                    ],
-                });
-                expect(status).toBe(201);
-                expect(body).toEqual([
-                    {
-                        id: expect.any(String),
-                        name: 'test3',
-                        createdAt: expect.any(String),
-                        updatedAt: expect.any(String),
-                    },
-                    {
-                        id: expect.any(String),
-                        name: 'test4',
-                        createdAt: expect.any(String),
-                        updatedAt: expect.any(String),
-                    },
-                ]);
-            });
-        });
-        describe('POST /test-entities', () => {
-            it('should create a test entity', async () => {
-                const { body, status } = await e2e_setup_1.server.post('/test-entities', { name: 'test3' });
-                expect(status).toBe(201);
-                expect(body).toEqual({
-                    id: expect.any(String),
-                    name: 'test3',
-                    createdAt: expect.any(String),
-                    updatedAt: expect.any(String),
-                });
-            });
-        });
-        describe('PUT /test-entities/:id', () => {
-            let entityToReplace;
-            beforeEach(async () => {
-                const { body } = await e2e_setup_1.server.get('/test-entities');
-                entityToReplace = body.pop();
-            });
-            it('should replace a test entity by id', async () => {
-                const { body, status } = await e2e_setup_1.server.put(`/test-entities/${entityToReplace.id}`, { name: 'test-replaced' });
-                expect(status).toBe(200);
-                expect(body).toEqual({
-                    id: expect.any(String),
-                    name: 'test-replaced',
-                    createdAt: expect.any(String),
-                    updatedAt: expect.any(String),
-                });
-            });
-            it('should return 404 if entity not found', async () => {
-                const { body, status } = await e2e_setup_1.server.put(`/test-entities/123`, { name: 'test1-updated' });
-                expect(status).toBe(404);
-                expect(body).toHaveProperty('error', 'Not Found');
-                expect(body).toHaveProperty('statusCode', 404);
-                expect(body).toHaveProperty('message', 'TestEntity not found');
-            });
-        });
-        describe('PATCH /test-entities', () => {
-            let entities;
-            beforeEach(async () => {
-                const { body } = await e2e_setup_1.server.get('/test-entities');
-                entities = body;
-            });
-            it('should update many test entities', async () => {
-                const { body, status } = await e2e_setup_1.server.patch('/test-entities', {
-                    group: 'many-patched',
-                }, { query: { ids: entities.map(({ id }) => id) } });
-                expect(status).toBe(200);
-                expect(body).toEqual([
-                    {
-                        ...entities[0],
-                        group: 'many-patched',
-                        updatedAt: expect.any(String),
-                    },
-                    {
-                        ...entities[1],
-                        group: 'many-patched',
-                        updatedAt: expect.any(String),
-                    },
-                ]);
-            });
-            it('should return 404 if entity not found', async () => {
-                const { body, status } = await e2e_setup_1.server.patch('/test-entities', {
-                    group: 'many-patched',
-                }, { query: { ids: ['123'] } });
-                expect(status).toBe(404);
-                expect(body).toHaveProperty('error', 'Not Found');
-                expect(body).toHaveProperty('statusCode', 404);
-                expect(body).toHaveProperty('message', 'TestEntity not found');
-            });
-        });
-        describe('PATCH /test-entities/:id', () => {
-            let entityToUpdate;
-            beforeEach(async () => {
-                const { body } = await e2e_setup_1.server.get('/test-entities');
-                entityToUpdate = body.pop();
-            });
-            it('should update a test entity by id', async () => {
-                const { body, status } = await e2e_setup_1.server.patch(`/test-entities/${entityToUpdate.id}`, { name: 'test-updated' });
-                expect(status).toBe(200);
-                expect(body).toEqual({
-                    id: expect.any(String),
-                    name: 'test-updated',
-                    createdAt: expect.any(String),
-                    updatedAt: expect.any(String),
-                });
-            });
-            it('should return 404 if entity not found', async () => {
-                const { body, status } = await e2e_setup_1.server.patch(`/test-entities/123`, { name: 'test1-updated' });
-                expect(status).toBe(404);
-                expect(body).toHaveProperty('error', 'Not Found');
-                expect(body).toHaveProperty('statusCode', 404);
-                expect(body).toHaveProperty('message', 'TestEntity not found');
-            });
-        });
-        describe('DELETE /test-entities', () => {
-            let entities;
-            beforeEach(async () => {
-                const { body } = await e2e_setup_1.server.get('/test-entities');
-                entities = body;
-            });
-            it('should delete many test entities', async () => {
-                const { body, status } = await e2e_setup_1.server.delete('/test-entities', { query: { ids: entities.map(({ id }) => id) } });
-                expect(status).toBe(200);
-                expect(body).toEqual({ deletedCount: 2 });
-                const model = await (0, utils_1.getModelFromEntity)(TestEntity);
-                const updatedList = await model.find().lean().exec();
-                expect(updatedList).toEqual([]);
-            });
-            it('should return 200 with 0 for deletedCount if one of entities is not found', async () => {
-                const { body, status } = await e2e_setup_1.server.delete('/test-entities', { query: { ids: [entities[0].id, '123'] } });
-                expect(status).toBe(200);
-                expect(body).toEqual({ deletedCount: 0 });
-            });
-        });
-        describe('DELETE /test-entities/:id', () => {
-            let entityToDelete;
-            beforeEach(async () => {
-                const { body } = await e2e_setup_1.server.get('/test-entities');
-                entityToDelete = body.pop();
-            });
-            it('should delete a test entity by id', async () => {
-                const { body, status } = await e2e_setup_1.server.delete(`/test-entities/${entityToDelete.id}`);
-                expect(status).toBe(200);
-                expect(body).toEqual({ deletedCount: 1 });
-            });
-            it('should return 200 with deletedCount at 0 if entity not found', async () => {
-                const { body, status } = await e2e_setup_1.server.delete(`/test-entities/123`);
-                expect(status).toBe(200);
-                expect(body).toEqual({ deletedCount: 0 });
-            });
-        });
-        describe('POST /test-entities/duplicate', () => {
-            let entities;
-            beforeEach(async () => {
-                const { body } = await e2e_setup_1.server.get('/test-entities');
-                entities = body;
-            });
-            it('should duplicate test entities', async () => {
-                const { body, status } = await e2e_setup_1.server.post('/test-entities/duplicate', {
-                    name: 'test1-duplicated',
-                    group: 'duplicated',
-                }, { query: { ids: [entities[0].id] } });
-                expect(status).toBe(201);
-                expect(body).toEqual([
-                    {
-                        ...entities[0],
-                        id: expect.any(String),
-                        name: 'test1-duplicated',
-                        group: 'duplicated',
-                        createdAt: expect.any(String),
-                        updatedAt: expect.any(String),
-                    },
-                ]);
-            });
-            it('should return 404 if one of entities is not found', async () => {
-                const { body, status } = await e2e_setup_1.server.post(`/test-entities/duplicate`, {
-                    group: 'duplicated',
-                }, { query: { ids: [entities[0].id, '123'] } });
-                expect(status).toBe(404);
-                expect(body).toHaveProperty('error', 'Not Found');
-                expect(body).toHaveProperty('statusCode', 404);
-                expect(body).toHaveProperty('message', 'TestEntity not found');
-            });
-        });
-        describe('POST /test-entities/duplicate/:id', () => {
-            let entityToDuplicate;
-            beforeEach(async () => {
-                const { body } = await e2e_setup_1.server.get('/test-entities');
-                entityToDuplicate = body.pop();
-            });
-            it('should duplicate a test entity by id', async () => {
-                const { body, status } = await e2e_setup_1.server.post(`/test-entities/duplicate/${entityToDuplicate.id}`, {
-                    name: 'test2-duplicated',
-                });
-                expect(status).toBe(201);
-                expect(body).toEqual({
-                    ...entityToDuplicate,
-                    id: expect.any(String),
-                    name: 'test2-duplicated',
-                    createdAt: expect.any(String),
-                    updatedAt: expect.any(String),
-                });
-            });
-            it('should return 404 if entity not found', async () => {
-                const { body, status } = await e2e_setup_1.server.post(`/test-entities/duplicate/123`, {
-                    name: 'test1-duplicated',
-                    group: 'duplicated',
-                });
-                expect(status).toBe(404);
-                expect(body).toHaveProperty('error', 'Not Found');
-                expect(body).toHaveProperty('statusCode', 404);
-                expect(body).toHaveProperty('message', 'TestEntity not found');
-            });
-        });
-    });
-    describe('Entity extends SoftDeletableEntity', () => {
-        let TestDeletableEntity = class TestDeletableEntity extends src_1.SoftDeletableEntity {
-        };
-        __decorate([
-            (0, mongoose_1.Prop)({ type: String, required: true }),
-            __metadata("design:type", String)
-        ], TestDeletableEntity.prototype, "name", void 0);
-        __decorate([
-            (0, mongoose_1.Prop)({ type: String }),
-            __metadata("design:type", String)
-        ], TestDeletableEntity.prototype, "group", void 0);
-        TestDeletableEntity = __decorate([
-            (0, src_1.DynamicAPISchemaOptions)({
-                indexes: [{ fields: { name: 1 }, options: { unique: true, partialFilterExpression: { deletedAt: { $eq: null } } } }],
-            }),
-            (0, mongoose_1.Schema)({ collection: 'test-entities' })
-        ], TestDeletableEntity);
-        beforeEach(async () => {
-            const fixtures = async (_) => {
-                const model = await (0, utils_1.getModelFromEntity)(TestDeletableEntity);
-                await model.insertMany([
-                    { name: 'test1' },
-                    { name: 'test2' },
-                ]);
-            };
-            await initApp({
-                entity: TestDeletableEntity,
-                controllerOptions: {
-                    path: 'test-entities',
-                },
-            }, {}, fixtures);
-        });
-        describe('GET /test-entities', () => {
-            it('should return all test entities', async () => {
-                const { body, status } = await e2e_setup_1.server.get('/test-entities');
-                expect(status).toBe(200);
-                expect(body).toEqual([
-                    {
-                        id: expect.any(String),
-                        name: 'test1',
-                        createdAt: expect.any(String),
-                        updatedAt: expect.any(String),
-                    },
-                    {
-                        id: expect.any(String),
-                        name: 'test2',
-                        createdAt: expect.any(String),
-                        updatedAt: expect.any(String),
-                    },
-                ]);
-            });
-        });
-        describe('GET /test-entities/:id', () => {
-            let entities;
-            beforeEach(async () => {
-                const { body } = await e2e_setup_1.server.get('/test-entities');
-                entities = body;
-            });
-            it('should return a test entity by id', async () => {
-                const { body, status } = await e2e_setup_1.server.get(`/test-entities/${entities[0].id}`);
-                expect(status).toBe(200);
-                expect(body).toEqual(entities[0]);
-            });
-            it('should return 404 if entity not found', async () => {
-                const { body, status } = await e2e_setup_1.server.get(`/test-entities/123`);
-                expect(status).toBe(404);
-                expect(body).toHaveProperty('error', 'Not Found');
-                expect(body).toHaveProperty('statusCode', 404);
-                expect(body).toHaveProperty('message', 'TestDeletableEntity not found');
-            });
-        });
-        describe('POST /test-entities/many', () => {
-            it('should create many test entities', async () => {
-                const { body, status } = await e2e_setup_1.server.post('/test-entities/many', {
-                    list: [
-                        { name: 'test3' },
-                        { name: 'test4' },
-                    ],
-                });
-                expect(status).toBe(201);
-                expect(body).toEqual([
-                    {
-                        id: expect.any(String),
-                        name: 'test3',
-                        createdAt: expect.any(String),
-                        updatedAt: expect.any(String),
-                    },
-                    {
-                        id: expect.any(String),
-                        name: 'test4',
-                        createdAt: expect.any(String),
-                        updatedAt: expect.any(String),
-                    },
-                ]);
-            });
-        });
-        describe('POST /test-entities', () => {
-            it('should create a test entity', async () => {
-                const { body, status } = await e2e_setup_1.server.post('/test-entities', { name: 'test3' });
-                expect(status).toBe(201);
-                expect(body).toEqual({
-                    id: expect.any(String),
-                    name: 'test3',
-                    createdAt: expect.any(String),
-                    updatedAt: expect.any(String),
-                });
-            });
-        });
-        describe('PUT /test-entities/:id', () => {
-            let entityToReplace;
-            beforeEach(async () => {
-                const { body } = await e2e_setup_1.server.get('/test-entities');
-                entityToReplace = body.pop();
-            });
-            it('should replace a test entity by id', async () => {
-                const { body, status } = await e2e_setup_1.server.put(`/test-entities/${entityToReplace.id}`, { name: 'test-replaced' });
-                expect(status).toBe(200);
-                expect(body).toEqual({
-                    id: expect.any(String),
-                    name: 'test-replaced',
-                    createdAt: expect.any(String),
-                    updatedAt: expect.any(String),
-                });
-            });
-            it('should return 404 if entity not found', async () => {
-                const { body, status } = await e2e_setup_1.server.put(`/test-entities/123`, { name: 'test1-updated' });
-                expect(status).toBe(404);
-                expect(body).toHaveProperty('error', 'Not Found');
-                expect(body).toHaveProperty('statusCode', 404);
-                expect(body).toHaveProperty('message', 'TestDeletableEntity not found');
-            });
-        });
-        describe('PATCH /test-entities', () => {
-            let entities;
-            beforeEach(async () => {
-                const { body } = await e2e_setup_1.server.get('/test-entities');
-                entities = body;
-            });
-            it('should update many test entities', async () => {
-                const { body, status } = await e2e_setup_1.server.patch('/test-entities', {
-                    group: 'many-patched',
-                }, { query: { ids: entities.map(({ id }) => id) } });
-                expect(status).toBe(200);
-                expect(body).toEqual([
-                    {
-                        ...entities[0],
-                        group: 'many-patched',
-                        updatedAt: expect.any(String),
-                    },
-                    {
-                        ...entities[1],
-                        group: 'many-patched',
-                        updatedAt: expect.any(String),
-                    },
-                ]);
-            });
-            it('should return 404 if entity not found', async () => {
-                const { body, status } = await e2e_setup_1.server.patch('/test-entities', {
-                    group: 'many-patched',
-                }, { query: { ids: ['123'] } });
-                expect(status).toBe(404);
-                expect(body).toHaveProperty('error', 'Not Found');
-                expect(body).toHaveProperty('statusCode', 404);
-                expect(body).toHaveProperty('message', 'TestDeletableEntity not found');
-            });
-        });
-        describe('PATCH /test-entities/:id', () => {
-            let entityToUpdate;
-            beforeEach(async () => {
-                const { body } = await e2e_setup_1.server.get('/test-entities');
-                entityToUpdate = body.pop();
-            });
-            it('should update a test entity by id', async () => {
-                const { body, status } = await e2e_setup_1.server.patch(`/test-entities/${entityToUpdate.id}`, { name: 'test-updated' });
-                expect(status).toBe(200);
-                expect(body).toEqual({
-                    id: expect.any(String),
-                    name: 'test-updated',
-                    createdAt: expect.any(String),
-                    updatedAt: expect.any(String),
-                });
-            });
-            it('should return 404 if entity not found', async () => {
-                const { body, status } = await e2e_setup_1.server.patch(`/test-entities/123`, { name: 'test1-updated' });
-                expect(status).toBe(404);
-                expect(body).toHaveProperty('error', 'Not Found');
-                expect(body).toHaveProperty('statusCode', 404);
-                expect(body).toHaveProperty('message', 'TestDeletableEntity not found');
-            });
-        });
-        describe('DELETE /test-entities', () => {
-            let entities;
-            beforeEach(async () => {
-                const { body } = await e2e_setup_1.server.get('/test-entities');
-                entities = body;
-            });
-            it('should delete many test entities', async () => {
-                const { body, status } = await e2e_setup_1.server.delete('/test-entities', { query: { ids: entities.map(({ id }) => id) } });
-                expect(status).toBe(200);
-                expect(body).toEqual({ deletedCount: 2 });
-                const model = await (0, utils_1.getModelFromEntity)(TestDeletableEntity);
-                const updatedList = await model.find().lean().exec();
-                expect(updatedList).toEqual([
-                    {
-                        _id: expect.any(Object),
-                        __v: expect.any(Number),
-                        name: 'test1',
-                        isDeleted: true,
-                        createdAt: expect.any(Date),
-                        updatedAt: expect.any(Date),
-                        deletedAt: expect.any(Date),
-                    },
-                    {
-                        _id: expect.any(Object),
-                        __v: expect.any(Number),
-                        name: 'test2',
-                        isDeleted: true,
-                        createdAt: expect.any(Date),
-                        updatedAt: expect.any(Date),
-                        deletedAt: expect.any(Date),
-                    },
-                ]);
-            });
-            it('should return 200 with 0 for deletedCount if one of entities is not found', async () => {
-                const { body, status } = await e2e_setup_1.server.delete('/test-entities', { query: { ids: [entities[0].id, '123'] } });
-                expect(status).toBe(200);
-                expect(body).toEqual({ deletedCount: 0 });
-            });
-        });
-        describe('DELETE /test-entities/:id', () => {
-            let entityToDelete;
-            beforeEach(async () => {
-                const { body } = await e2e_setup_1.server.get('/test-entities');
-                entityToDelete = body.pop();
-            });
-            it('should delete a test entity by id', async () => {
-                const { body, status } = await e2e_setup_1.server.delete(`/test-entities/${entityToDelete.id}`);
-                expect(status).toBe(200);
-                expect(body).toEqual({ deletedCount: 1 });
-            });
-            it('should return 200 with deletedCount at 0 if entity not found', async () => {
-                const { body, status } = await e2e_setup_1.server.delete(`/test-entities/123`);
-                expect(status).toBe(200);
-                expect(body).toEqual({ deletedCount: 0 });
-            });
-        });
-        describe('POST /test-entities/duplicate', () => {
-            let entities;
-            beforeEach(async () => {
-                const { body } = await e2e_setup_1.server.get('/test-entities');
-                entities = body;
-            });
-            it('should duplicate test entities', async () => {
-                const { body, status } = await e2e_setup_1.server.post('/test-entities/duplicate', {
-                    name: 'test1-duplicated',
-                    group: 'duplicated',
-                }, { query: { ids: [entities[0].id] } });
-                expect(status).toBe(201);
-                expect(body).toEqual([
-                    {
-                        ...entities[0],
-                        id: expect.any(String),
-                        name: 'test1-duplicated',
-                        group: 'duplicated',
-                        createdAt: expect.any(String),
-                        updatedAt: expect.any(String),
-                    },
-                ]);
-            });
-            it('should return 404 if one of entities is not found', async () => {
-                const { body, status } = await e2e_setup_1.server.post(`/test-entities/duplicate`, {
-                    group: 'duplicated',
-                }, { query: { ids: [entities[0].id, '123'] } });
-                expect(status).toBe(404);
-                expect(body).toHaveProperty('error', 'Not Found');
-                expect(body).toHaveProperty('statusCode', 404);
-                expect(body).toHaveProperty('message', 'TestDeletableEntity not found');
-            });
-        });
-        describe('POST /test-entities/duplicate/:id', () => {
-            let entityToDuplicate;
-            beforeEach(async () => {
-                const { body } = await e2e_setup_1.server.get('/test-entities');
-                entityToDuplicate = body.pop();
-            });
-            it('should duplicate a test entity by id', async () => {
-                const { body, status } = await e2e_setup_1.server.post(`/test-entities/duplicate/${entityToDuplicate.id}`, {
-                    name: 'test2-duplicated',
-                });
-                expect(status).toBe(201);
-                expect(body).toEqual({
-                    ...entityToDuplicate,
-                    id: expect.any(String),
-                    name: 'test2-duplicated',
-                    createdAt: expect.any(String),
-                    updatedAt: expect.any(String),
-                });
-            });
-            it('should return 404 if entity not found', async () => {
-                const { body, status } = await e2e_setup_1.server.post(`/test-entities/duplicate/123`, {
-                    name: 'test1-duplicated',
-                    group: 'duplicated',
-                });
-                expect(status).toBe(404);
-                expect(body).toHaveProperty('error', 'Not Found');
-                expect(body).toHaveProperty('statusCode', 404);
-                expect(body).toHaveProperty('message', 'TestDeletableEntity not found');
-            });
-        });
-    });
-    describe('Websockets', () => {
-        let UserEntity = class UserEntity extends src_1.BaseEntity {
-        };
-        __decorate([
-            (0, mongoose_1.Prop)({ type: String, required: true }),
-            __metadata("design:type", String)
-        ], UserEntity.prototype, "email", void 0);
-        __decorate([
-            (0, mongoose_1.Prop)({ type: String, required: true }),
-            __metadata("design:type", String)
-        ], UserEntity.prototype, "password", void 0);
-        __decorate([
-            (0, mongoose_1.Prop)({ type: Boolean, default: false }),
-            __metadata("design:type", Boolean)
-        ], UserEntity.prototype, "isAdmin", void 0);
-        UserEntity = __decorate([
-            (0, mongoose_1.Schema)({ collection: 'users' })
-        ], UserEntity);
-        let ProductEntity = class ProductEntity extends src_1.BaseEntity {
-        };
-        __decorate([
-            (0, mongoose_1.Prop)({ type: String, required: true }),
-            __metadata("design:type", String)
-        ], ProductEntity.prototype, "name", void 0);
-        __decorate([
-            (0, mongoose_1.Prop)({ type: Boolean, default: false }),
-            __metadata("design:type", Boolean)
-        ], ProductEntity.prototype, "inStock", void 0);
-        __decorate([
-            (0, mongoose_1.Prop)({ type: String }),
-            __metadata("design:type", String)
-        ], ProductEntity.prototype, "status", void 0);
-        ProductEntity = __decorate([
-            (0, mongoose_1.Schema)({ collection: 'products' })
-        ], ProductEntity);
-        const customEvent = 'product-custom-event';
-        let adminAccessToken;
-        let userAccessToken;
-        let firstProduct;
-        let secondProduct;
-        beforeEach(async () => {
-            const fixtures = async (_) => {
-                const model = await (0, utils_1.getModelFromEntity)(ProductEntity);
-                await model.insertMany([
-                    { name: 'mayo', inStock: true },
-                    { name: 'ketchup' },
-                ]).then(([mayoProduct, ketchupProduct]) => {
-                    firstProduct = mayoProduct;
-                    secondProduct = ketchupProduct;
-                });
-            };
-            await initApp({
-                entity: ProductEntity,
-                controllerOptions: {
-                    apiTag: 'Product',
-                    path: 'products',
-                },
-                routes: [
-                    { type: 'GetMany', isPublic: true },
-                    {
-                        type: 'CreateMany',
-                        webSocket: true,
-                        broadcast: {
-                            enabled: (_, user) => user.isAdmin === true,
-                        },
-                    },
-                    {
-                        type: 'CreateOne',
-                        webSocket: true,
-                        broadcast: { enabled: true },
-                    },
-                    {
-                        type: 'UpdateMany',
-                        webSocket: true,
-                        broadcast: {
-                            enabled: false,
-                            eventName: customEvent,
-                        },
-                    },
-                    {
-                        type: 'UpdateOne',
-                        webSocket: true,
-                        broadcast: {
-                            enabled: true,
-                            eventName: customEvent,
-                        },
-                    },
-                    {
-                        type: 'ReplaceOne',
-                        webSocket: true,
-                        broadcast: {
-                            enabled: true,
-                        },
-                    },
-                    {
-                        type: 'DuplicateOne',
-                        webSocket: true,
-                        broadcast: {
-                            enabled: (_, user) => user.isAdmin === true,
-                            eventName: customEvent,
-                        },
-                    },
-                    {
-                        type: 'DuplicateMany',
-                        webSocket: true,
-                        broadcast: {
-                            enabled: true,
-                        },
-                    },
-                    {
-                        type: 'DeleteOne',
-                        webSocket: true,
-                        broadcast: {
-                            enabled: true,
-                        },
-                    },
-                    {
-                        type: 'DeleteMany',
-                        webSocket: true,
-                        broadcast: {
-                            enabled: true,
-                        },
-                    },
-                ],
-            }, {
-                useAuth: {
-                    userEntity: UserEntity,
-                    login: {
-                        additionalFields: ['isAdmin'],
-                    },
-                    webSocket: true,
-                },
-            }, fixtures, async (app) => {
-                app.useWebSocketAdapter(new e2e_setup_1.TestSocketAdapter(app));
-            }, true);
-            adminAccessToken = (await e2e_setup_1.server.emit('auth-register', { email: 'unit@test.co', password: 'test', isAdmin: true })).accessToken;
-            userAccessToken = (await e2e_setup_1.server.emit('auth-register', { email: 'toto@test.co', password: 'test' })).accessToken;
-        });
-        it('[CreateOne] should broadcast created product to all clients', async () => {
-            await e2e_setup_1.server.emit('create-one-product', { name: 'mustard', inStock: true }, { accessToken: adminAccessToken, expectBroadcast: true });
-            expect(e2e_setup_1.handleSocketBroadcast).toHaveBeenCalledTimes(1);
-            expect(e2e_setup_1.handleSocketBroadcast).toHaveBeenCalledWith({
-                event: 'create-one-product',
-                data: expect.arrayContaining([
-                    expect.objectContaining({
-                        name: 'mustard',
-                        inStock: true,
-                    }),
-                ]),
-            });
-        });
-        it('[CreateMany] should broadcast created products to all clients when admin', async () => {
-            await e2e_setup_1.server.emit('create-many-product', {
-                list: [
-                    { name: 'mustard', inStock: true },
-                    { name: 'relish', inStock: false },
-                ],
-            }, { accessToken: adminAccessToken, expectBroadcast: true });
-            expect(e2e_setup_1.handleSocketBroadcast).toHaveBeenCalledTimes(1);
-            expect(e2e_setup_1.handleSocketBroadcast).toHaveBeenCalledWith({
-                event: 'create-many-product',
-                data: expect.arrayContaining([
-                    expect.objectContaining({
-                        name: 'mustard',
-                        inStock: true,
-                    }),
-                    expect.objectContaining({
-                        name: 'relish',
-                        inStock: false,
-                    }),
-                ]),
-            });
-        });
-        it('[CreateMany] should NOT broadcast created products when user is not admin', async () => {
-            await e2e_setup_1.server.emit('create-many-product', {
-                list: [
-                    { name: 'pickles', inStock: true },
-                    { name: 'onions', inStock: false },
-                ],
-            }, { accessToken: userAccessToken });
-            expect(e2e_setup_1.handleSocketBroadcast).not.toHaveBeenCalled();
-        });
-        it('[UpdateOne] should broadcast updated product to all clients with custom event name', async () => {
-            await e2e_setup_1.server.emit('update-one-product', {
-                id: firstProduct.id,
-                name: 'updated mayo',
-                inStock: false,
-            }, { accessToken: adminAccessToken, broadcastEvent: customEvent, expectBroadcast: true });
-            expect(e2e_setup_1.handleSocketBroadcast).toHaveBeenCalledTimes(1);
-            expect(e2e_setup_1.handleSocketBroadcast).toHaveBeenCalledWith({
-                event: customEvent,
-                data: expect.arrayContaining([
-                    expect.objectContaining({
-                        id: firstProduct.id,
-                        name: 'updated mayo',
-                        inStock: false,
-                    }),
-                ]),
-            });
-        });
-        it('[UpdateMany] should NOT broadcast updated products when broadcast is disabled', async () => {
-            const { body: products } = await e2e_setup_1.server.get('/products');
-            await e2e_setup_1.server.emit('update-many-product', {
-                ids: products.map(p => p.id),
-                status: 'updated',
-            }, { accessToken: adminAccessToken });
-            expect(e2e_setup_1.handleSocketBroadcast).not.toHaveBeenCalled();
-        });
-        it('[DeleteOne] should broadcast deleted product id to all clients', async () => {
-            await e2e_setup_1.server.emit('delete-one-product', {
-                id: firstProduct.id,
-            }, { accessToken: adminAccessToken, expectBroadcast: true });
-            expect(e2e_setup_1.handleSocketBroadcast).toHaveBeenCalledTimes(1);
-            expect(e2e_setup_1.handleSocketBroadcast).toHaveBeenCalledWith({
-                event: 'delete-one-product',
-                data: expect.arrayContaining([
-                    expect.objectContaining({
-                        id: firstProduct.id,
-                    }),
-                ]),
-            });
-        });
-        it('[ReplaceOne] should broadcast replaced product to all clients', async () => {
-            await e2e_setup_1.server.emit('replace-one-product', {
-                id: firstProduct.id,
-                name: 'replaced mayo',
-                inStock: false,
-            }, { accessToken: adminAccessToken, expectBroadcast: true });
-            expect(e2e_setup_1.handleSocketBroadcast).toHaveBeenCalledTimes(1);
-            expect(e2e_setup_1.handleSocketBroadcast).toHaveBeenCalledWith({
-                event: 'replace-one-product',
-                data: expect.arrayContaining([
-                    expect.objectContaining({
-                        id: firstProduct.id,
-                        name: 'replaced mayo',
-                        inStock: false,
-                    }),
-                ]),
-            });
-        });
-        it('[DuplicateOne] should broadcast duplicated product to all clients with custom event name when admin', async () => {
-            await e2e_setup_1.server.emit('duplicate-one-product', {
-                id: firstProduct.id,
-                name: 'duplicated mayo',
-            }, { accessToken: adminAccessToken, broadcastEvent: customEvent, expectBroadcast: true });
-            expect(e2e_setup_1.handleSocketBroadcast).toHaveBeenCalledTimes(1);
-            expect(e2e_setup_1.handleSocketBroadcast).toHaveBeenCalledWith({
-                event: customEvent,
-                data: expect.arrayContaining([
-                    expect.objectContaining({
-                        name: 'duplicated mayo',
-                        inStock: firstProduct.inStock,
-                    }),
-                ]),
-            });
-        });
-        it('[DuplicateOne] should NOT broadcast duplicated product when user is not admin', async () => {
-            await e2e_setup_1.server.emit('duplicate-one-product', {
-                id: firstProduct.id,
-                name: 'duplicated mayo user',
-            }, { accessToken: userAccessToken });
-            expect(e2e_setup_1.handleSocketBroadcast).not.toHaveBeenCalled();
-        });
-        it('[DuplicateMany] should broadcast duplicated products to all clients', async () => {
-            await e2e_setup_1.server.emit('duplicate-many-product', {
-                ids: [secondProduct.id, firstProduct.id],
-                status: 'duplicated',
-            }, { accessToken: adminAccessToken, expectBroadcast: true });
-            expect(e2e_setup_1.handleSocketBroadcast).toHaveBeenCalledTimes(1);
-            expect(e2e_setup_1.handleSocketBroadcast).toHaveBeenCalledWith({
-                event: 'duplicate-many-product',
-                data: expect.arrayContaining([
-                    expect.objectContaining({
-                        id: expect.any(String),
-                        name: secondProduct.name,
-                        inStock: secondProduct.inStock,
-                        status: 'duplicated',
-                    }),
-                    expect.objectContaining({
-                        id: expect.any(String),
-                        name: firstProduct.name,
-                        inStock: firstProduct.inStock,
-                        status: 'duplicated',
-                    }),
-                ]),
-            });
-        });
-        it('[DeleteMany] should broadcast deleted product ids to all clients', async () => {
-            const products = [firstProduct, secondProduct];
-            await e2e_setup_1.server.emit('delete-many-product', {
-                ids: products.map(p => p.id),
-            }, { accessToken: adminAccessToken, expectBroadcast: true });
-            expect(e2e_setup_1.handleSocketBroadcast).toHaveBeenCalledTimes(1);
-            expect(e2e_setup_1.handleSocketBroadcast).toHaveBeenCalledWith({
-                event: 'delete-many-product',
-                data: expect.arrayContaining(products.map(p => ({ id: p.id }))),
-            });
-        });
-    });
-    describe('HTTP Broadcast', () => {
-        let HbProductEntity = class HbProductEntity extends src_1.BaseEntity {
-        };
-        __decorate([
-            (0, mongoose_1.Prop)({ type: String, required: true }),
-            __metadata("design:type", String)
-        ], HbProductEntity.prototype, "name", void 0);
-        __decorate([
-            (0, mongoose_1.Prop)({ type: Boolean, default: false }),
-            __metadata("design:type", Boolean)
-        ], HbProductEntity.prototype, "inStock", void 0);
-        __decorate([
-            (0, mongoose_1.Prop)({ type: String }),
-            __metadata("design:type", String)
-        ], HbProductEntity.prototype, "status", void 0);
-        HbProductEntity = __decorate([
-            (0, mongoose_1.Schema)({ collection: 'hb_products' })
-        ], HbProductEntity);
-        const customEvent = 'hb-product-custom-event';
-        let firstProduct;
-        let secondProduct;
-        beforeEach(async () => {
-            const fixtures = async (_) => {
-                const model = await (0, utils_1.getModelFromEntity)(HbProductEntity);
-                await model.insertMany([
-                    { name: 'mayo', inStock: true },
-                    { name: 'ketchup', inStock: false },
-                ]).then(([mayoProduct, ketchupProduct]) => {
-                    firstProduct = mayoProduct;
-                    secondProduct = ketchupProduct;
-                });
-            };
-            await initApp({
-                entity: HbProductEntity,
-                controllerOptions: {
-                    apiTag: 'HbProduct',
-                    path: 'hb-products',
-                    isPublic: true,
-                },
-                routes: [
-                    { type: 'GetMany', isPublic: true },
-                    {
-                        type: 'CreateOne',
-                        broadcast: { enabled: true },
-                    },
-                    {
-                        type: 'CreateMany',
-                        broadcast: { enabled: (data) => data.inStock === true },
-                    },
-                    {
-                        type: 'UpdateOne',
-                        broadcast: { enabled: true, eventName: customEvent },
-                    },
-                    {
-                        type: 'UpdateMany',
-                        broadcast: { enabled: false },
-                    },
-                    {
-                        type: 'ReplaceOne',
-                        broadcast: { enabled: true },
-                    },
-                    {
-                        type: 'DuplicateOne',
-                        broadcast: { enabled: true },
-                    },
-                    {
-                        type: 'DuplicateMany',
-                        broadcast: { enabled: true },
-                    },
-                    {
-                        type: 'DeleteOne',
-                        broadcast: { enabled: true },
-                    },
-                    {
-                        type: 'DeleteMany',
-                        broadcast: { enabled: true },
-                    },
-                ],
-            }, undefined, fixtures, async (app) => {
-                app.useWebSocketAdapter(new e2e_setup_1.TestSocketAdapter(app));
-            }, true);
-        });
-        it('[CreateOne] should broadcast created product to all WS clients after HTTP call', async () => {
-            const { broadcastData } = await e2e_setup_1.server.httpWithBroadcast('post', '/hb-products', { name: 'mustard', inStock: true }, { broadcastEvent: 'create-one-hb-product' });
-            expect(e2e_setup_1.handleSocketBroadcast).toHaveBeenCalledTimes(1);
-            expect(e2e_setup_1.handleSocketBroadcast).toHaveBeenCalledWith({
-                event: 'create-one-hb-product',
-                data: expect.arrayContaining([
-                    expect.objectContaining({ name: 'mustard', inStock: true }),
-                ]),
-            });
-            expect(broadcastData).toEqual(expect.arrayContaining([
-                expect.objectContaining({ name: 'mustard', inStock: true }),
-            ]));
-        });
-        it('[CreateMany] should broadcast only inStock products after HTTP call', async () => {
-            const { broadcastData } = await e2e_setup_1.server.httpWithBroadcast('post', '/hb-products/many', { list: [{ name: 'pickles', inStock: true }, { name: 'onions', inStock: false }] }, { broadcastEvent: 'create-many-hb-product' });
-            expect(e2e_setup_1.handleSocketBroadcast).toHaveBeenCalledTimes(1);
-            expect(broadcastData).toEqual(expect.arrayContaining([expect.objectContaining({ name: 'pickles', inStock: true })]));
-            expect(broadcastData).not.toEqual(expect.arrayContaining([expect.objectContaining({ name: 'onions' })]));
-        });
-        it('[UpdateOne] should broadcast updated product with custom event name after HTTP call', async () => {
-            const { broadcastData } = await e2e_setup_1.server.httpWithBroadcast('patch', `/hb-products/${firstProduct.id}`, { name: 'updated mayo', inStock: false }, { broadcastEvent: customEvent });
-            expect(e2e_setup_1.handleSocketBroadcast).toHaveBeenCalledTimes(1);
-            expect(e2e_setup_1.handleSocketBroadcast).toHaveBeenCalledWith({
-                event: customEvent,
-                data: expect.arrayContaining([
-                    expect.objectContaining({ id: firstProduct.id, name: 'updated mayo', inStock: false }),
-                ]),
-            });
-            expect(broadcastData).toEqual(expect.arrayContaining([
-                expect.objectContaining({ name: 'updated mayo' }),
-            ]));
-        });
-        it('[ReplaceOne] should broadcast replaced product after HTTP call', async () => {
-            const { broadcastData } = await e2e_setup_1.server.httpWithBroadcast('put', `/hb-products/${firstProduct.id}`, { name: 'replaced mayo', inStock: false }, { broadcastEvent: 'replace-one-hb-product' });
-            expect(e2e_setup_1.handleSocketBroadcast).toHaveBeenCalledTimes(1);
-            expect(broadcastData).toEqual(expect.arrayContaining([
-                expect.objectContaining({ id: firstProduct.id, name: 'replaced mayo', inStock: false }),
-            ]));
-        });
-        it('[DuplicateOne] should broadcast duplicated product after HTTP call', async () => {
-            const { broadcastData } = await e2e_setup_1.server.httpWithBroadcast('post', `/hb-products/duplicate/${firstProduct.id}`, { name: 'duplicated mayo' }, { broadcastEvent: 'duplicate-one-hb-product' });
-            expect(e2e_setup_1.handleSocketBroadcast).toHaveBeenCalledTimes(1);
-            expect(broadcastData).toEqual(expect.arrayContaining([
-                expect.objectContaining({ name: 'duplicated mayo', inStock: firstProduct.inStock }),
-            ]));
-        });
-        it('[DuplicateMany] should broadcast duplicated products after HTTP call', async () => {
-            const { broadcastData } = await e2e_setup_1.server.httpWithBroadcast('post', '/hb-products/duplicate', { status: 'dup' }, {
-                broadcastEvent: 'duplicate-many-hb-product',
-                query: { ids: [firstProduct.id, secondProduct.id] },
-            });
-            expect(e2e_setup_1.handleSocketBroadcast).toHaveBeenCalledTimes(1);
-            expect(broadcastData.length).toBeGreaterThanOrEqual(2);
-        });
-        it('[DeleteOne] should broadcast deleted product id to all WS clients after HTTP call', async () => {
-            const { broadcastData } = await e2e_setup_1.server.httpWithBroadcast('delete', `/hb-products/${firstProduct.id}`, {}, { broadcastEvent: 'delete-one-hb-product' });
-            expect(e2e_setup_1.handleSocketBroadcast).toHaveBeenCalledTimes(1);
-            expect(e2e_setup_1.handleSocketBroadcast).toHaveBeenCalledWith({
-                event: 'delete-one-hb-product',
-                data: expect.arrayContaining([expect.objectContaining({ id: firstProduct.id })]),
-            });
-            expect(broadcastData).toEqual(expect.arrayContaining([{ id: firstProduct.id }]));
-        });
-        it('[DeleteMany] should broadcast deleted product ids to all WS clients after HTTP call', async () => {
-            const ids = [firstProduct.id, secondProduct.id];
-            const { broadcastData } = await e2e_setup_1.server.httpWithBroadcast('delete', '/hb-products', {}, {
-                broadcastEvent: 'delete-many-hb-product',
-                query: { ids },
-            });
-            expect(e2e_setup_1.handleSocketBroadcast).toHaveBeenCalledTimes(1);
-            expect(broadcastData).toEqual(expect.arrayContaining(ids.map(id => ({ id }))));
-        });
-        it('[UpdateMany] should NOT broadcast when enabled is false', async () => {
-            const { body: products } = await e2e_setup_1.server.get('/hb-products');
-            const ids = products.map((p) => p.id);
-            const response = await e2e_setup_1.server.patch(`/hb-products/many?ids=${ids.join('&ids=')}`, { status: 'updated' });
-            expect(response).toBeDefined();
-            expect(e2e_setup_1.handleSocketBroadcast).not.toHaveBeenCalled();
-        });
-    });
-});
-//# sourceMappingURL=dynamic-api-for-feature.e2e-spec.js.map