mongodb-dynamic-api 3.0.1 → 3.2.0

package/src/services/dynamic-api-broadcast/dynamic-api-broadcast.service.d.ts

@@ -0,0 +1,7 @@
+import { Server } from 'socket.io';
+import { DynamicApiBroadcastConfig } from '../../interfaces';
+export declare class DynamicApiBroadcastService {
+    private static wsServer;
+    setWsServer(server: Server): void;
+    broadcastFromHttp<T extends object>(event: string, data: T[], broadcastConfig: DynamicApiBroadcastConfig<T>): void;
+}

package/src/services/dynamic-api-broadcast/dynamic-api-broadcast.service.js

@@ -0,0 +1,38 @@
+"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 DynamicApiBroadcastService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamicApiBroadcastService = void 0;
+const common_1 = require("@nestjs/common");
+let DynamicApiBroadcastService = DynamicApiBroadcastService_1 = class DynamicApiBroadcastService {
+    setWsServer(server) {
+        DynamicApiBroadcastService_1.wsServer = server;
+    }
+    broadcastFromHttp(event, data, broadcastConfig) {
+        if (!DynamicApiBroadcastService_1.wsServer || !broadcastConfig || !data?.length) {
+            return;
+        }
+        const { enabled, eventName } = broadcastConfig;
+        if (typeof enabled === 'boolean' && !enabled) {
+            return;
+        }
+        const broadcastData = typeof enabled === 'function'
+            ? data.filter((item) => enabled(item, undefined))
+            : data;
+        if (!broadcastData.length) {
+            return;
+        }
+        DynamicApiBroadcastService_1.wsServer.emit(eventName || event, broadcastData);
+    }
+};
+exports.DynamicApiBroadcastService = DynamicApiBroadcastService;
+DynamicApiBroadcastService.wsServer = null;
+exports.DynamicApiBroadcastService = DynamicApiBroadcastService = DynamicApiBroadcastService_1 = __decorate([
+    (0, common_1.Injectable)()
+], DynamicApiBroadcastService);
+//# sourceMappingURL=dynamic-api-broadcast.service.js.map

package/src/services/dynamic-api-broadcast/dynamic-api-broadcast.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamic-api-broadcast.service.js","sourceRoot":"","sources":["../../../../libs/dynamic-api/src/services/dynamic-api-broadcast/dynamic-api-broadcast.service.ts"],"names":[],"mappings":";;;;;;;;;;AAAA,2CAA4C;AAKrC,IAAM,0BAA0B,kCAAhC,MAAM,0BAA0B;IAGrC,WAAW,CAAC,MAAc;QACxB,4BAA0B,CAAC,QAAQ,GAAG,MAAM,CAAC;IAC/C,CAAC;IAED,iBAAiB,CACf,KAAa,EACb,IAAS,EACT,eAA6C;QAE7C,IAAI,CAAC,4BAA0B,CAAC,QAAQ,IAAI,CAAC,eAAe,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC;YAC9E,OAAO;QACT,CAAC;QAED,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,GAAG,eAAe,CAAC;QAE/C,IAAI,OAAO,OAAO,KAAK,SAAS,IAAI,CAAC,OAAO,EAAE,CAAC;YAC7C,OAAO;QACT,CAAC;QAED,MAAM,aAAa,GAAG,OAAO,OAAO,KAAK,UAAU;YACjD,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAE,OAAoB,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;YAC/D,CAAC,CAAC,IAAI,CAAC;QAET,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,CAAC;YAC1B,OAAO;QACT,CAAC;QAED,4BAA0B,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS,IAAI,KAAK,EAAE,aAAa,CAAC,CAAC;IAC9E,CAAC;;AA/BU,gEAA0B;AACtB,mCAAQ,GAAkB,IAAI,AAAtB,CAAuB;qCADnC,0BAA0B;IADtC,IAAA,mBAAU,GAAE;GACA,0BAA0B,CAgCtC"}

package/src/services/index.d.ts

@@ -1,3 +1,4 @@
 export * from './base/base.service';
 export * from './bcrypt/bcrypt.service';
+export * from './dynamic-api-broadcast/dynamic-api-broadcast.service';
 export * from './dynamic-api-global-state/dynamic-api-global-state.service';

package/src/services/index.js

@@ -16,5 +16,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./base/base.service"), exports);
 __exportStar(require("./bcrypt/bcrypt.service"), exports);
+__exportStar(require("./dynamic-api-broadcast/dynamic-api-broadcast.service"), exports);
 __exportStar(require("./dynamic-api-global-state/dynamic-api-global-state.service"), exports);
 //# sourceMappingURL=index.js.map

package/src/services/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../libs/dynamic-api/src/services/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,sDAAoC;AACpC,0DAAwC;AACxC,8FAA4E"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../libs/dynamic-api/src/services/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,sDAAoC;AACpC,0DAAwC;AACxC,wFAAsE;AACtE,8FAA4E"}

package/src/version.json

@@ -1,3 +1,3 @@
 {
-    "version": "3.0.1"
+    "version": "3.2.0"
 }

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

@@ -18,12 +18,13 @@ 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) => {
+    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);
     };
@@ -634,5 +635,466 @@ describe('DynamicApiModule forFeature (e2e)', () => {
             });
         });
     });
+    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