mongodb-dynamic-api 4.4.0 → 4.6.0

package/test/for-feature/callbacks-user.e2e-spec.js

@@ -0,0 +1,772 @@
+"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");
+describe('Callbacks receive authenticated user (e2e)', () => {
+    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);
+    UserEntity = __decorate([
+        (0, mongoose_1.Schema)({ collection: 'users-cb' })
+    ], UserEntity);
+    let ItemEntity = class ItemEntity extends src_1.BaseEntity {
+    };
+    __decorate([
+        (0, mongoose_1.Prop)({ type: String, required: true }),
+        __metadata("design:type", String)
+    ], ItemEntity.prototype, "name", void 0);
+    __decorate([
+        (0, mongoose_1.Prop)({ type: String }),
+        __metadata("design:type", String)
+    ], ItemEntity.prototype, "createdBy", void 0);
+    __decorate([
+        (0, mongoose_1.Prop)({ type: String }),
+        __metadata("design:type", String)
+    ], ItemEntity.prototype, "updatedBy", void 0);
+    ItemEntity = __decorate([
+        (0, mongoose_1.Schema)({ collection: 'items-cb' })
+    ], ItemEntity);
+    let AuditLogEntity = class AuditLogEntity extends src_1.BaseEntity {
+    };
+    __decorate([
+        (0, mongoose_1.Prop)({ type: String, required: true }),
+        __metadata("design:type", String)
+    ], AuditLogEntity.prototype, "action", void 0);
+    __decorate([
+        (0, mongoose_1.Prop)({ type: String, required: true }),
+        __metadata("design:type", String)
+    ], AuditLogEntity.prototype, "entityId", void 0);
+    __decorate([
+        (0, mongoose_1.Prop)({ type: String }),
+        __metadata("design:type", String)
+    ], AuditLogEntity.prototype, "performedBy", void 0);
+    AuditLogEntity = __decorate([
+        (0, mongoose_1.Schema)({ collection: 'audit-logs-cb' })
+    ], AuditLogEntity);
+    const createOneBeforeSave = async (_entity, context, _methods, user) => {
+        const u = user;
+        return { ...context.toCreate, createdBy: u?.email ?? 'anonymous' };
+    };
+    const createOneAfterSave = async (entity, methods, user) => {
+        const u = user;
+        await methods.createOneDocument(AuditLogEntity, {
+            action: 'CreateOne',
+            entityId: entity.id,
+            performedBy: u?.email ?? 'anonymous',
+        });
+    };
+    const createManyBeforeSave = async (_entities, context, _methods, user) => {
+        const u = user;
+        return context.toCreate.map((item) => ({ ...item, createdBy: u?.email ?? 'anonymous' }));
+    };
+    const createManyAfterSave = async (entity, methods, user) => {
+        const u = user;
+        await methods.createOneDocument(AuditLogEntity, {
+            action: 'CreateMany',
+            entityId: entity.id,
+            performedBy: u?.email ?? 'anonymous',
+        });
+    };
+    const updateOneBeforeSave = async (_entity, context, _methods, user) => {
+        const u = user;
+        return { ...context.update, updatedBy: u?.email ?? 'anonymous' };
+    };
+    const updateOneAfterSave = async (entity, methods, user) => {
+        const u = user;
+        await methods.createOneDocument(AuditLogEntity, {
+            action: 'UpdateOne',
+            entityId: entity.id,
+            performedBy: u?.email ?? 'anonymous',
+        });
+    };
+    const updateManyBeforeSave = async (entities, context, _methods, user) => {
+        const u = user;
+        return entities.map(() => ({ ...context.update, updatedBy: u?.email ?? 'anonymous' }));
+    };
+    const updateManyAfterSave = async (entity, methods, user) => {
+        const u = user;
+        await methods.createOneDocument(AuditLogEntity, {
+            action: 'UpdateMany',
+            entityId: entity.id,
+            performedBy: u?.email ?? 'anonymous',
+        });
+    };
+    const replaceOneBeforeSave = async (_entity, context, _methods, user) => {
+        const u = user;
+        return { ...context.replacement, updatedBy: u?.email ?? 'anonymous' };
+    };
+    const replaceOneAfterSave = async (entity, methods, user) => {
+        const u = user;
+        await methods.createOneDocument(AuditLogEntity, {
+            action: 'ReplaceOne',
+            entityId: entity.id,
+            performedBy: u?.email ?? 'anonymous',
+        });
+    };
+    const duplicateOneBeforeSave = async (_entity, context, _methods, user) => {
+        const u = user;
+        return { ...(context.override ?? {}), createdBy: u?.email ?? 'anonymous' };
+    };
+    const duplicateOneAfterSave = async (entity, methods, user) => {
+        const u = user;
+        await methods.createOneDocument(AuditLogEntity, {
+            action: 'DuplicateOne',
+            entityId: entity.id,
+            performedBy: u?.email ?? 'anonymous',
+        });
+    };
+    const duplicateManyBeforeSave = async (entities, context, _methods, user) => {
+        const u = user;
+        return entities.map((e) => ({
+            name: e.name,
+            ...(context.override ?? {}),
+            createdBy: u?.email ?? 'anonymous',
+        }));
+    };
+    const duplicateManyAfterSave = async (entity, methods, user) => {
+        const u = user;
+        await methods.createOneDocument(AuditLogEntity, {
+            action: 'DuplicateMany',
+            entityId: entity.id,
+            performedBy: u?.email ?? 'anonymous',
+        });
+    };
+    const deleteOneBeforeSave = async (entity, _context, methods, user) => {
+        const u = user;
+        if (entity) {
+            await methods.createOneDocument(AuditLogEntity, {
+                action: 'DeleteOne-before',
+                entityId: entity.id,
+                performedBy: u?.email ?? 'anonymous',
+            });
+        }
+    };
+    const deleteOneAfterSave = async (entity, methods, user) => {
+        const u = user;
+        await methods.createOneDocument(AuditLogEntity, {
+            action: 'DeleteOne',
+            entityId: entity.id,
+            performedBy: u?.email ?? 'anonymous',
+        });
+    };
+    const deleteManyBeforeSave = async (entities, _context, methods, user) => {
+        const u = user;
+        for (const entity of entities) {
+            await methods.createOneDocument(AuditLogEntity, {
+                action: 'DeleteMany-before',
+                entityId: entity._id?.toString() ?? entity.id,
+                performedBy: u?.email ?? 'anonymous',
+            });
+        }
+    };
+    const deleteManyAfterSave = async (entity, methods, user) => {
+        const u = user;
+        await methods.createOneDocument(AuditLogEntity, {
+            action: 'DeleteMany',
+            entityId: entity.id,
+            performedBy: u?.email ?? 'anonymous',
+        });
+    };
+    const getOneAfterSave = async (entity, methods, user) => {
+        const u = user;
+        await methods.createOneDocument(AuditLogEntity, {
+            action: 'GetOne',
+            entityId: entity.id,
+            performedBy: u?.email ?? 'anonymous',
+        });
+    };
+    const getManyAfterSave = async (entity, methods, user) => {
+        const u = user;
+        await methods.createOneDocument(AuditLogEntity, {
+            action: 'GetMany',
+            entityId: entity.id,
+            performedBy: u?.email ?? 'anonymous',
+        });
+    };
+    const routes = [
+        { type: 'CreateOne', callback: createOneAfterSave, beforeSaveCallback: createOneBeforeSave },
+        { type: 'CreateMany', callback: createManyAfterSave, beforeSaveCallback: createManyBeforeSave },
+        { type: 'UpdateOne', callback: updateOneAfterSave, beforeSaveCallback: updateOneBeforeSave },
+        { type: 'UpdateMany', callback: updateManyAfterSave, beforeSaveCallback: updateManyBeforeSave },
+        { type: 'ReplaceOne', callback: replaceOneAfterSave, beforeSaveCallback: replaceOneBeforeSave },
+        { type: 'DuplicateOne', callback: duplicateOneAfterSave, beforeSaveCallback: duplicateOneBeforeSave },
+        { type: 'DuplicateMany', callback: duplicateManyAfterSave, beforeSaveCallback: duplicateManyBeforeSave },
+        { type: 'DeleteOne', callback: deleteOneAfterSave, beforeSaveCallback: deleteOneBeforeSave },
+        { type: 'DeleteMany', callback: deleteManyAfterSave, beforeSaveCallback: deleteManyBeforeSave },
+        { type: 'GetOne', callback: getOneAfterSave },
+        { type: 'GetMany', callback: getManyAfterSave },
+    ];
+    let accessToken;
+    const userEmail = 'cb-test@test.co';
+    const userPassword = 'test';
+    beforeEach(async () => {
+        src_1.DynamicApiModule.state['resetState']();
+        const uri = process.env.MONGO_DB_URL;
+        const moduleRef = await testing_1.Test.createTestingModule({
+            imports: [
+                src_1.DynamicApiModule.forRoot(uri, { useAuth: { userEntity: UserEntity } }),
+                src_1.DynamicApiModule.forFeature({
+                    entity: ItemEntity,
+                    controllerOptions: { path: 'items' },
+                    routes,
+                }),
+                src_1.DynamicApiModule.forFeature({
+                    entity: AuditLogEntity,
+                    controllerOptions: { path: 'audit-logs' },
+                }),
+            ],
+        }).compile();
+        await (0, e2e_setup_1.createTestingApp)(moduleRef);
+        await e2e_setup_1.server.post('/auth/register', { email: userEmail, password: userPassword });
+        const { body } = await e2e_setup_1.server.post('/auth/login', { email: userEmail, password: userPassword });
+        accessToken = body.accessToken;
+    });
+    afterEach(async () => {
+        await (0, e2e_setup_1.closeTestingApp)(mongoose_2.default.connections);
+    });
+    const auth = () => ({ authToken: accessToken });
+    const getAuditLogs = async (action) => {
+        const { body } = await e2e_setup_1.server.get('/audit-logs', auth());
+        return body.filter((log) => log.action === action);
+    };
+    describe('CreateOne', () => {
+        it('beforeSaveCallback should set createdBy from user and afterSave should create audit log', async () => {
+            const { body, status } = await e2e_setup_1.server.post('/items', { name: 'item-1' }, auth());
+            expect(status).toBe(201);
+            expect(body.createdBy).toBe(userEmail);
+            const logs = await getAuditLogs('CreateOne');
+            expect(logs).toHaveLength(1);
+            expect(logs[0]).toEqual(expect.objectContaining({
+                action: 'CreateOne',
+                entityId: body.id,
+                performedBy: userEmail,
+            }));
+        });
+    });
+    describe('CreateMany', () => {
+        it('beforeSaveCallback should set createdBy from user and afterSave should create audit logs', async () => {
+            const { body, status } = await e2e_setup_1.server.post('/items/many', { list: [{ name: 'item-a' }, { name: 'item-b' }] }, auth());
+            expect(status).toBe(201);
+            expect(body).toHaveLength(2);
+            expect(body[0].createdBy).toBe(userEmail);
+            expect(body[1].createdBy).toBe(userEmail);
+            const logs = await getAuditLogs('CreateMany');
+            expect(logs).toHaveLength(2);
+            expect(logs.every((l) => l.performedBy === userEmail)).toBe(true);
+        });
+    });
+    describe('UpdateOne', () => {
+        it('beforeSaveCallback should set updatedBy from user and afterSave should create audit log', async () => {
+            const { body: created } = await e2e_setup_1.server.post('/items', { name: 'to-update' }, auth());
+            const { body: updated, status } = await e2e_setup_1.server.patch(`/items/${created.id}`, { name: 'updated-name' }, auth());
+            expect(status).toBe(200);
+            expect(updated.updatedBy).toBe(userEmail);
+            expect(updated.name).toBe('updated-name');
+            const logs = await getAuditLogs('UpdateOne');
+            expect(logs).toHaveLength(1);
+            expect(logs[0].performedBy).toBe(userEmail);
+        });
+    });
+    describe('UpdateMany', () => {
+        it('beforeSaveCallback should set updatedBy from user and afterSave should create audit logs', async () => {
+            const { body: items } = await e2e_setup_1.server.post('/items/many', { list: [{ name: 'um-1' }, { name: 'um-2' }] }, auth());
+            const ids = items.map((i) => i.id);
+            const { body: updated, status } = await e2e_setup_1.server.patch('/items', { name: 'bulk-updated' }, { ...auth(), query: { ids } });
+            expect(status).toBe(200);
+            expect(updated).toHaveLength(2);
+            expect(updated.every((u) => u.updatedBy === userEmail)).toBe(true);
+            const logs = await getAuditLogs('UpdateMany');
+            expect(logs).toHaveLength(2);
+            expect(logs.every((l) => l.performedBy === userEmail)).toBe(true);
+        });
+    });
+    describe('ReplaceOne', () => {
+        it('beforeSaveCallback should set updatedBy from user and afterSave should create audit log', async () => {
+            const { body: created } = await e2e_setup_1.server.post('/items', { name: 'to-replace' }, auth());
+            const { body: replaced, status } = await e2e_setup_1.server.put(`/items/${created.id}`, { name: 'replaced-name' }, auth());
+            expect(status).toBe(200);
+            expect(replaced.updatedBy).toBe(userEmail);
+            expect(replaced.name).toBe('replaced-name');
+            const logs = await getAuditLogs('ReplaceOne');
+            expect(logs).toHaveLength(1);
+            expect(logs[0].performedBy).toBe(userEmail);
+        });
+    });
+    describe('DuplicateOne', () => {
+        it('beforeSaveCallback should set createdBy from user and afterSave should create audit log', async () => {
+            const { body: created } = await e2e_setup_1.server.post('/items', { name: 'to-dup' }, auth());
+            const { body: duplicated, status } = await e2e_setup_1.server.post(`/items/duplicate/${created.id}`, { name: 'dup-name' }, auth());
+            expect(status).toBe(201);
+            expect(duplicated.createdBy).toBe(userEmail);
+            const logs = await getAuditLogs('DuplicateOne');
+            expect(logs).toHaveLength(1);
+            expect(logs[0]).toEqual(expect.objectContaining({
+                entityId: duplicated.id,
+                performedBy: userEmail,
+            }));
+        });
+    });
+    describe('DuplicateMany', () => {
+        it('beforeSaveCallback should set createdBy from user and afterSave should create audit logs', async () => {
+            const { body: items } = await e2e_setup_1.server.post('/items/many', { list: [{ name: 'dm-1' }, { name: 'dm-2' }] }, auth());
+            const ids = items.map((i) => i.id);
+            const { body: duplicated, status } = await e2e_setup_1.server.post('/items/duplicate', {}, { ...auth(), query: { ids } });
+            expect(status).toBe(201);
+            expect(duplicated).toHaveLength(2);
+            expect(duplicated.every((d) => d.createdBy === userEmail)).toBe(true);
+            const logs = await getAuditLogs('DuplicateMany');
+            expect(logs).toHaveLength(2);
+            expect(logs.every((l) => l.performedBy === userEmail)).toBe(true);
+        });
+    });
+    describe('DeleteOne', () => {
+        it('beforeSaveCallback and afterSave should both create audit logs with user', async () => {
+            const { body: created } = await e2e_setup_1.server.post('/items', { name: 'to-delete' }, auth());
+            const { body, status } = await e2e_setup_1.server.delete(`/items/${created.id}`, auth());
+            expect(status).toBe(200);
+            expect(body.deletedCount).toBe(1);
+            const beforeLogs = await getAuditLogs('DeleteOne-before');
+            expect(beforeLogs).toHaveLength(1);
+            expect(beforeLogs[0].performedBy).toBe(userEmail);
+            const afterLogs = await getAuditLogs('DeleteOne');
+            expect(afterLogs).toHaveLength(1);
+            expect(afterLogs[0]).toEqual(expect.objectContaining({
+                entityId: created.id,
+                performedBy: userEmail,
+            }));
+        });
+    });
+    describe('DeleteMany', () => {
+        it('beforeSaveCallback and afterSave should both create audit logs with user', async () => {
+            const { body: items } = await e2e_setup_1.server.post('/items/many', { list: [{ name: 'del-1' }, { name: 'del-2' }] }, auth());
+            const ids = items.map((i) => i.id);
+            const { body, status } = await e2e_setup_1.server.delete('/items', { ...auth(), query: { ids } });
+            expect(status).toBe(200);
+            expect(body.deletedCount).toBe(2);
+            const beforeLogs = await getAuditLogs('DeleteMany-before');
+            expect(beforeLogs).toHaveLength(2);
+            expect(beforeLogs.every((l) => l.performedBy === userEmail)).toBe(true);
+            const afterLogs = await getAuditLogs('DeleteMany');
+            expect(afterLogs).toHaveLength(2);
+            expect(afterLogs.every((l) => l.performedBy === userEmail)).toBe(true);
+        });
+    });
+    describe('GetOne', () => {
+        it('afterSave callback should create audit log with user', async () => {
+            const { body: created } = await e2e_setup_1.server.post('/items', { name: 'get-one-item' }, auth());
+            const { status } = await e2e_setup_1.server.get(`/items/${created.id}`, auth());
+            expect(status).toBe(200);
+            const logs = await getAuditLogs('GetOne');
+            expect(logs).toHaveLength(1);
+            expect(logs[0]).toEqual(expect.objectContaining({
+                entityId: created.id,
+                performedBy: userEmail,
+            }));
+        });
+    });
+    describe('GetMany', () => {
+        it('afterSave callback should create audit logs with user for each returned entity', async () => {
+            await e2e_setup_1.server.post('/items/many', { list: [{ name: 'gm-1' }, { name: 'gm-2' }] }, auth());
+            const { body: items, status } = await e2e_setup_1.server.get('/items', auth());
+            expect(status).toBe(200);
+            const logs = await getAuditLogs('GetMany');
+            expect(logs.length).toBe(items.length);
+            expect(logs.every((l) => l.performedBy === userEmail)).toBe(true);
+        });
+    });
+});
+describe('Callbacks receive authenticated user via WebSocket (e2e)', () => {
+    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);
+    UserEntity = __decorate([
+        (0, mongoose_1.Schema)({ collection: 'users-cb-ws' })
+    ], UserEntity);
+    let ItemEntity = class ItemEntity extends src_1.BaseEntity {
+    };
+    __decorate([
+        (0, mongoose_1.Prop)({ type: String, required: true }),
+        __metadata("design:type", String)
+    ], ItemEntity.prototype, "name", void 0);
+    __decorate([
+        (0, mongoose_1.Prop)({ type: String }),
+        __metadata("design:type", String)
+    ], ItemEntity.prototype, "createdBy", void 0);
+    __decorate([
+        (0, mongoose_1.Prop)({ type: String }),
+        __metadata("design:type", String)
+    ], ItemEntity.prototype, "updatedBy", void 0);
+    ItemEntity = __decorate([
+        (0, mongoose_1.Schema)({ collection: 'items-cb-ws' })
+    ], ItemEntity);
+    let AuditLogEntity = class AuditLogEntity extends src_1.BaseEntity {
+    };
+    __decorate([
+        (0, mongoose_1.Prop)({ type: String, required: true }),
+        __metadata("design:type", String)
+    ], AuditLogEntity.prototype, "action", void 0);
+    __decorate([
+        (0, mongoose_1.Prop)({ type: String, required: true }),
+        __metadata("design:type", String)
+    ], AuditLogEntity.prototype, "entityId", void 0);
+    __decorate([
+        (0, mongoose_1.Prop)({ type: String }),
+        __metadata("design:type", String)
+    ], AuditLogEntity.prototype, "performedBy", void 0);
+    AuditLogEntity = __decorate([
+        (0, mongoose_1.Schema)({ collection: 'audit-logs-cb-ws' })
+    ], AuditLogEntity);
+    const createOneBeforeSave = async (_entity, context, _methods, user) => {
+        const u = user;
+        return { ...context.toCreate, createdBy: u?.email ?? 'anonymous' };
+    };
+    const createOneAfterSave = async (entity, methods, user) => {
+        const u = user;
+        await methods.createOneDocument(AuditLogEntity, {
+            action: 'WS-CreateOne',
+            entityId: entity.id,
+            performedBy: u?.email ?? 'anonymous',
+        });
+    };
+    const createManyBeforeSave = async (_entities, context, _methods, user) => {
+        const u = user;
+        return context.toCreate.map((item) => ({ ...item, createdBy: u?.email ?? 'anonymous' }));
+    };
+    const createManyAfterSave = async (entity, methods, user) => {
+        const u = user;
+        await methods.createOneDocument(AuditLogEntity, {
+            action: 'WS-CreateMany',
+            entityId: entity.id,
+            performedBy: u?.email ?? 'anonymous',
+        });
+    };
+    const updateOneBeforeSave = async (_entity, context, _methods, user) => {
+        const u = user;
+        return { ...context.update, updatedBy: u?.email ?? 'anonymous' };
+    };
+    const updateOneAfterSave = async (entity, methods, user) => {
+        const u = user;
+        await methods.createOneDocument(AuditLogEntity, {
+            action: 'WS-UpdateOne',
+            entityId: entity.id,
+            performedBy: u?.email ?? 'anonymous',
+        });
+    };
+    const updateManyBeforeSave = async (entities, context, _methods, user) => {
+        const u = user;
+        return entities.map(() => ({ ...context.update, updatedBy: u?.email ?? 'anonymous' }));
+    };
+    const updateManyAfterSave = async (entity, methods, user) => {
+        const u = user;
+        await methods.createOneDocument(AuditLogEntity, {
+            action: 'WS-UpdateMany',
+            entityId: entity.id,
+            performedBy: u?.email ?? 'anonymous',
+        });
+    };
+    const replaceOneBeforeSave = async (_entity, context, _methods, user) => {
+        const u = user;
+        return { ...context.replacement, updatedBy: u?.email ?? 'anonymous' };
+    };
+    const replaceOneAfterSave = async (entity, methods, user) => {
+        const u = user;
+        await methods.createOneDocument(AuditLogEntity, {
+            action: 'WS-ReplaceOne',
+            entityId: entity.id,
+            performedBy: u?.email ?? 'anonymous',
+        });
+    };
+    const duplicateOneBeforeSave = async (_entity, context, _methods, user) => {
+        const u = user;
+        return { ...(context.override ?? {}), createdBy: u?.email ?? 'anonymous' };
+    };
+    const duplicateOneAfterSave = async (entity, methods, user) => {
+        const u = user;
+        await methods.createOneDocument(AuditLogEntity, {
+            action: 'WS-DuplicateOne',
+            entityId: entity.id,
+            performedBy: u?.email ?? 'anonymous',
+        });
+    };
+    const duplicateManyBeforeSave = async (entities, context, _methods, user) => {
+        const u = user;
+        return entities.map((e) => ({
+            name: e.name,
+            ...(context.override ?? {}),
+            createdBy: u?.email ?? 'anonymous',
+        }));
+    };
+    const duplicateManyAfterSave = async (entity, methods, user) => {
+        const u = user;
+        await methods.createOneDocument(AuditLogEntity, {
+            action: 'WS-DuplicateMany',
+            entityId: entity.id,
+            performedBy: u?.email ?? 'anonymous',
+        });
+    };
+    const deleteOneBeforeSave = async (entity, _context, methods, user) => {
+        const u = user;
+        if (entity) {
+            await methods.createOneDocument(AuditLogEntity, {
+                action: 'WS-DeleteOne-before',
+                entityId: entity.id,
+                performedBy: u?.email ?? 'anonymous',
+            });
+        }
+    };
+    const deleteOneAfterSave = async (entity, methods, user) => {
+        const u = user;
+        await methods.createOneDocument(AuditLogEntity, {
+            action: 'WS-DeleteOne',
+            entityId: entity.id,
+            performedBy: u?.email ?? 'anonymous',
+        });
+    };
+    const deleteManyBeforeSave = async (entities, _context, methods, user) => {
+        const u = user;
+        for (const entity of entities) {
+            await methods.createOneDocument(AuditLogEntity, {
+                action: 'WS-DeleteMany-before',
+                entityId: entity._id?.toString() ?? entity.id,
+                performedBy: u?.email ?? 'anonymous',
+            });
+        }
+    };
+    const deleteManyAfterSave = async (entity, methods, user) => {
+        const u = user;
+        await methods.createOneDocument(AuditLogEntity, {
+            action: 'WS-DeleteMany',
+            entityId: entity.id,
+            performedBy: u?.email ?? 'anonymous',
+        });
+    };
+    const getOneAfterSave = async (entity, methods, user) => {
+        const u = user;
+        await methods.createOneDocument(AuditLogEntity, {
+            action: 'WS-GetOne',
+            entityId: entity.id,
+            performedBy: u?.email ?? 'anonymous',
+        });
+    };
+    const getManyAfterSave = async (entity, methods, user) => {
+        const u = user;
+        await methods.createOneDocument(AuditLogEntity, {
+            action: 'WS-GetMany',
+            entityId: entity.id,
+            performedBy: u?.email ?? 'anonymous',
+        });
+    };
+    const wsRoutes = [
+        { type: 'CreateOne', webSocket: true, callback: createOneAfterSave, beforeSaveCallback: createOneBeforeSave },
+        { type: 'CreateMany', webSocket: true, callback: createManyAfterSave, beforeSaveCallback: createManyBeforeSave },
+        { type: 'UpdateOne', webSocket: true, callback: updateOneAfterSave, beforeSaveCallback: updateOneBeforeSave },
+        { type: 'UpdateMany', webSocket: true, callback: updateManyAfterSave, beforeSaveCallback: updateManyBeforeSave },
+        { type: 'ReplaceOne', webSocket: true, callback: replaceOneAfterSave, beforeSaveCallback: replaceOneBeforeSave },
+        { type: 'DuplicateOne', webSocket: true, callback: duplicateOneAfterSave, beforeSaveCallback: duplicateOneBeforeSave },
+        { type: 'DuplicateMany', webSocket: true, callback: duplicateManyAfterSave, beforeSaveCallback: duplicateManyBeforeSave },
+        { type: 'DeleteOne', webSocket: true, callback: deleteOneAfterSave, beforeSaveCallback: deleteOneBeforeSave },
+        { type: 'DeleteMany', webSocket: true, callback: deleteManyAfterSave, beforeSaveCallback: deleteManyBeforeSave },
+        { type: 'GetOne', webSocket: true, callback: getOneAfterSave },
+        { type: 'GetMany', webSocket: true, callback: getManyAfterSave },
+    ];
+    let accessToken;
+    const userEmail = 'ws-cb-test@test.co';
+    const userPassword = 'test';
+    beforeEach(async () => {
+        src_1.DynamicApiModule.state['resetState']();
+        const uri = process.env.MONGO_DB_URL;
+        const moduleRef = await testing_1.Test.createTestingModule({
+            imports: [
+                src_1.DynamicApiModule.forRoot(uri, {
+                    useAuth: { userEntity: UserEntity, webSocket: true },
+                }),
+                src_1.DynamicApiModule.forFeature({
+                    entity: ItemEntity,
+                    controllerOptions: { path: 'items' },
+                    routes: wsRoutes,
+                }),
+                src_1.DynamicApiModule.forFeature({
+                    entity: AuditLogEntity,
+                    controllerOptions: { path: 'audit-logs' },
+                }),
+            ],
+        }).compile();
+        await (0, e2e_setup_1.createTestingApp)(moduleRef, undefined, async (app) => {
+            app.useWebSocketAdapter(new e2e_setup_1.TestSocketAdapter(app));
+        });
+        const registerResult = await e2e_setup_1.server.emit('auth-register', { email: userEmail, password: userPassword });
+        accessToken = registerResult.accessToken;
+    });
+    afterEach(async () => {
+        await (0, e2e_setup_1.closeTestingApp)(mongoose_2.default.connections);
+    });
+    const wsAuth = () => ({ accessToken });
+    const getAuditLogs = async (action) => {
+        const { body } = await e2e_setup_1.server.get('/audit-logs', { authToken: accessToken });
+        return body.filter((log) => log.action === action);
+    };
+    describe('CreateOne', () => {
+        it('beforeSaveCallback should set createdBy from socket user and afterSave should create audit log', async () => {
+            const result = await e2e_setup_1.server.emit('create-one-item-entity', { name: 'ws-item-1' }, wsAuth());
+            expect(result).toEqual(expect.objectContaining({ name: 'ws-item-1', createdBy: userEmail }));
+            const logs = await getAuditLogs('WS-CreateOne');
+            expect(logs).toHaveLength(1);
+            expect(logs[0]).toEqual(expect.objectContaining({
+                action: 'WS-CreateOne',
+                entityId: result.id,
+                performedBy: userEmail,
+            }));
+        });
+    });
+    describe('CreateMany', () => {
+        it('beforeSaveCallback should set createdBy from socket user and afterSave should create audit logs', async () => {
+            const result = await e2e_setup_1.server.emit('create-many-item-entity', { list: [{ name: 'ws-a' }, { name: 'ws-b' }] }, wsAuth());
+            expect(result).toHaveLength(2);
+            expect(result[0].createdBy).toBe(userEmail);
+            expect(result[1].createdBy).toBe(userEmail);
+            const logs = await getAuditLogs('WS-CreateMany');
+            expect(logs).toHaveLength(2);
+            expect(logs.every((l) => l.performedBy === userEmail)).toBe(true);
+        });
+    });
+    describe('UpdateOne', () => {
+        it('beforeSaveCallback should set updatedBy from socket user and afterSave should create audit log', async () => {
+            const created = await e2e_setup_1.server.emit('create-one-item-entity', { name: 'ws-to-update' }, wsAuth());
+            const updated = await e2e_setup_1.server.emit('update-one-item-entity', { id: created.id, name: 'ws-updated' }, wsAuth());
+            expect(updated.updatedBy).toBe(userEmail);
+            expect(updated.name).toBe('ws-updated');
+            const logs = await getAuditLogs('WS-UpdateOne');
+            expect(logs).toHaveLength(1);
+            expect(logs[0].performedBy).toBe(userEmail);
+        });
+    });
+    describe('UpdateMany', () => {
+        it('beforeSaveCallback should set updatedBy from socket user and afterSave should create audit logs', async () => {
+            const items = await e2e_setup_1.server.emit('create-many-item-entity', { list: [{ name: 'ws-um-1' }, { name: 'ws-um-2' }] }, wsAuth());
+            const ids = items.map((i) => i.id);
+            const updated = await e2e_setup_1.server.emit('update-many-item-entity', { ids, name: 'ws-bulk-updated' }, wsAuth());
+            expect(updated).toHaveLength(2);
+            expect(updated.every((u) => u.updatedBy === userEmail)).toBe(true);
+            const logs = await getAuditLogs('WS-UpdateMany');
+            expect(logs).toHaveLength(2);
+            expect(logs.every((l) => l.performedBy === userEmail)).toBe(true);
+        });
+    });
+    describe('ReplaceOne', () => {
+        it('beforeSaveCallback should set updatedBy from socket user and afterSave should create audit log', async () => {
+            const created = await e2e_setup_1.server.emit('create-one-item-entity', { name: 'ws-to-replace' }, wsAuth());
+            const replaced = await e2e_setup_1.server.emit('replace-one-item-entity', { id: created.id, name: 'ws-replaced' }, wsAuth());
+            expect(replaced.updatedBy).toBe(userEmail);
+            expect(replaced.name).toBe('ws-replaced');
+            const logs = await getAuditLogs('WS-ReplaceOne');
+            expect(logs).toHaveLength(1);
+            expect(logs[0].performedBy).toBe(userEmail);
+        });
+    });
+    describe('DuplicateOne', () => {
+        it('beforeSaveCallback should set createdBy from socket user and afterSave should create audit log', async () => {
+            const created = await e2e_setup_1.server.emit('create-one-item-entity', { name: 'ws-to-dup' }, wsAuth());
+            const duplicated = await e2e_setup_1.server.emit('duplicate-one-item-entity', { id: created.id, name: 'ws-dup-name' }, wsAuth());
+            expect(duplicated.createdBy).toBe(userEmail);
+            const logs = await getAuditLogs('WS-DuplicateOne');
+            expect(logs).toHaveLength(1);
+            expect(logs[0]).toEqual(expect.objectContaining({
+                entityId: duplicated.id,
+                performedBy: userEmail,
+            }));
+        });
+    });
+    describe('DuplicateMany', () => {
+        it('beforeSaveCallback should set createdBy from socket user and afterSave should create audit logs', async () => {
+            const items = await e2e_setup_1.server.emit('create-many-item-entity', { list: [{ name: 'ws-dm-1' }, { name: 'ws-dm-2' }] }, wsAuth());
+            const ids = items.map((i) => i.id);
+            const duplicated = await e2e_setup_1.server.emit('duplicate-many-item-entity', { ids }, wsAuth());
+            expect(duplicated).toHaveLength(2);
+            expect(duplicated.every((d) => d.createdBy === userEmail)).toBe(true);
+            const logs = await getAuditLogs('WS-DuplicateMany');
+            expect(logs).toHaveLength(2);
+            expect(logs.every((l) => l.performedBy === userEmail)).toBe(true);
+        });
+    });
+    describe('DeleteOne', () => {
+        it('beforeSaveCallback and afterSave should both create audit logs with socket user', async () => {
+            const created = await e2e_setup_1.server.emit('create-one-item-entity', { name: 'ws-to-delete' }, wsAuth());
+            const deleteResult = await e2e_setup_1.server.emit('delete-one-item-entity', { id: created.id }, wsAuth());
+            expect(deleteResult.deletedCount).toBe(1);
+            const beforeLogs = await getAuditLogs('WS-DeleteOne-before');
+            expect(beforeLogs).toHaveLength(1);
+            expect(beforeLogs[0].performedBy).toBe(userEmail);
+            const afterLogs = await getAuditLogs('WS-DeleteOne');
+            expect(afterLogs).toHaveLength(1);
+            expect(afterLogs[0]).toEqual(expect.objectContaining({
+                entityId: created.id,
+                performedBy: userEmail,
+            }));
+        });
+    });
+    describe('DeleteMany', () => {
+        it('beforeSaveCallback and afterSave should both create audit logs with socket user', async () => {
+            const items = await e2e_setup_1.server.emit('create-many-item-entity', { list: [{ name: 'ws-del-1' }, { name: 'ws-del-2' }] }, wsAuth());
+            const ids = items.map((i) => i.id);
+            const deleteResult = await e2e_setup_1.server.emit('delete-many-item-entity', { ids }, wsAuth());
+            expect(deleteResult.deletedCount).toBe(2);
+            const beforeLogs = await getAuditLogs('WS-DeleteMany-before');
+            expect(beforeLogs).toHaveLength(2);
+            expect(beforeLogs.every((l) => l.performedBy === userEmail)).toBe(true);
+            const afterLogs = await getAuditLogs('WS-DeleteMany');
+            expect(afterLogs).toHaveLength(2);
+            expect(afterLogs.every((l) => l.performedBy === userEmail)).toBe(true);
+        });
+    });
+    describe('GetOne', () => {
+        it('afterSave callback should create audit log with socket user', async () => {
+            const created = await e2e_setup_1.server.emit('create-one-item-entity', { name: 'ws-get-one-item' }, wsAuth());
+            const result = await e2e_setup_1.server.emit('get-one-item-entity', { id: created.id }, wsAuth());
+            expect(result).toEqual(expect.objectContaining({ id: created.id }));
+            const logs = await getAuditLogs('WS-GetOne');
+            expect(logs).toHaveLength(1);
+            expect(logs[0]).toEqual(expect.objectContaining({
+                entityId: created.id,
+                performedBy: userEmail,
+            }));
+        });
+    });
+    describe('GetMany', () => {
+        it('afterSave callback should create audit logs with socket user for each returned entity', async () => {
+            const items = await e2e_setup_1.server.emit('create-many-item-entity', { list: [{ name: 'ws-gm-1' }, { name: 'ws-gm-2' }] }, wsAuth());
+            const result = await e2e_setup_1.server.emit('get-many-item-entity', {}, wsAuth());
+            expect(result.length).toBeGreaterThanOrEqual(items.length);
+            const logs = await getAuditLogs('WS-GetMany');
+            expect(logs.length).toBe(result.length);
+            expect(logs.every((l) => l.performedBy === userEmail)).toBe(true);
+        });
+    });
+});
+//# sourceMappingURL=callbacks-user.e2e-spec.js.map