@futdevpro/nts-dynamo 1.15.139 → 1.15.141

package/build/_services/base/data.service.spec.js

@@ -1,614 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const data_service_1 = require("./data.service");
-const global_service_1 = require("../core/global.service");
-const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
-const global_settings_const_1 = require("../../_collections/global-settings.const");
-// Initialize global settings before any test runs
-beforeAll(() => {
-    if (!global_settings_const_1.DyNTS_global_settings.systemShortCodeName) {
-        global_settings_const_1.DyNTS_global_settings.systemShortCodeName = 'TEST';
-    }
-    if (!global_settings_const_1.DyNTS_global_settings.env_settings) {
-        global_settings_const_1.DyNTS_global_settings.env_settings = {
-            environment: fsm_dynamo_1.DyFM_EnvironmentFlag.local,
-        };
-    }
-});
-class TestMetadata extends fsm_dynamo_1.DyFM_Metadata {
-    name;
-    email;
-    userId;
-}
-const testDataParams = new fsm_dynamo_1.DyFM_DataModel_Params({
-    dataName: 'test_data',
-    properties: {
-        name: {
-            key: 'name',
-            type: fsm_dynamo_1.DyFM_BasicProperty_Type.string,
-            required: true,
-        },
-        email: {
-            key: 'email',
-            type: fsm_dynamo_1.DyFM_BasicProperty_Type.string,
-        },
-        userId: {
-            key: 'userId',
-            type: fsm_dynamo_1.DyFM_BasicProperty_Type.string,
-            dependencyDataName: 'user_data',
-        },
-    },
-});
-describe('| DyNTS_DataService', () => {
-    let mockDBService;
-    let service;
-    let testData;
-    beforeEach(() => {
-        testData = new TestMetadata({
-            _id: 'test-id-123',
-            name: 'Test Name',
-            email: 'test@example.com',
-        });
-        mockDBService = jasmine.createSpyObj('DyNTS_DBService', [
-            'getAll',
-            'getDataById',
-            'getDataListByIds',
-            'getDataByDependencyId',
-            'getDataListByDependencyIds',
-            'getDataListByDependencyId',
-            'findOne',
-            'find',
-            'updateOne',
-            'createData',
-            'modifyData',
-            'markDeletedById',
-            'trueDeleteDataById',
-            'trueDeleteAllData',
-            'restoreDeletedById',
-        ]);
-        spyOn(global_service_1.DyNTS_GlobalService, 'getDBService').and.returnValue(mockDBService);
-        spyOn(global_service_1.DyNTS_GlobalService, 'getDBServiceByKey').and.returnValue(mockDBService);
-        service = new data_service_1.DyNTS_DataService(testData, testDataParams, 'test-issuer');
-    });
-    it('| should create service instance', () => {
-        expect(service).toBeDefined();
-        expect(service.data).toBe(testData);
-        expect(service.dataParams).toBe(testDataParams);
-        expect(service.issuer).toBe('test-issuer');
-        expect(service.dataDBService).toBe(mockDBService);
-    });
-    it('| should set service name from constructor', () => {
-        expect(service.serviceName).toBe('DyNTS_DataService');
-    });
-    it('| should have default error messages', () => {
-        expect(service.defaultErrorUserMsg).toContain('Data Service Error');
-        expect(service.defaultValidationErrorUserMsg).toContain('Validation Error');
-    });
-    it('| should throw error when DB service not found', () => {
-        global_service_1.DyNTS_GlobalService.getDBService.and.throwError('DB Service not found');
-        expect(() => {
-            new data_service_1.DyNTS_DataService(testData, testDataParams, 'test-issuer');
-        }).toThrow();
-    });
-    describe('| getAll', () => {
-        it('| should get all data from database', async () => {
-            const mockDataList = [testData, { ...testData, _id: 'test-id-456' }];
-            mockDBService.getAll.and.returnValue(Promise.resolve(mockDataList));
-            const result = await service.getAll();
-            expect(result).toEqual(mockDataList);
-            expect(service.dataList).toEqual(mockDataList);
-            expect(mockDBService.getAll).toHaveBeenCalled();
-        });
-        it('| should not set to service when dontSetToService is true', async () => {
-            const mockDataList = [testData];
-            mockDBService.getAll.and.returnValue(Promise.resolve(mockDataList));
-            const result = await service.getAll(true);
-            expect(result).toEqual(mockDataList);
-            expect(service.dataList).not.toEqual(mockDataList);
-        });
-    });
-    describe('| getDataById', () => {
-        it('| should get data by id', async () => {
-            mockDBService.getDataById.and.returnValue(Promise.resolve(testData));
-            const result = await service.getDataById('test-id-123');
-            expect(result).toBe(testData);
-            expect(service.data).toBe(testData);
-            expect(mockDBService.getDataById).toHaveBeenCalledWith('test-id-123');
-        });
-        it('| should use data._id when id not provided', async () => {
-            mockDBService.getDataById.and.returnValue(Promise.resolve(testData));
-            const result = await service.getDataById();
-            expect(mockDBService.getDataById).toHaveBeenCalledWith('test-id-123');
-        });
-        it('| should throw error when id is missing', async () => {
-            service.data = new TestMetadata({});
-            await expectAsync(service.getDataById()).toBeRejected();
-        });
-        it('| should load from archive when not found and archive enabled', async () => {
-            service.haveArchiveDataService = true;
-            mockDBService.getDataById.and.returnValue(Promise.resolve(null));
-            const mockArchiveService = jasmine.createSpyObj('DyNTS_ArchiveDataService', ['getDataByOriginalId']);
-            mockArchiveService.getDataByOriginalId.and.returnValue(Promise.resolve(testData));
-            spyOn(service, 'getArchiveDataService').and.returnValue(mockArchiveService);
-            const result = await service.getDataById('test-id-123');
-            expect(result).toBe(testData);
-            expect(mockArchiveService.getDataByOriginalId).toHaveBeenCalled();
-        });
-        it('| should not load from archive when skipArchiveLoad is true', async () => {
-            service.haveArchiveDataService = true;
-            mockDBService.getDataById.and.returnValue(Promise.resolve(null));
-            spyOn(service, 'getArchiveDataService');
-            const result = await service.getDataById('test-id-123', false, true);
-            expect(result).toBeNull();
-            expect(service.getArchiveDataService).not.toHaveBeenCalled();
-        });
-    });
-    describe('| getDataByIds', () => {
-        it('| should get data by ids', async () => {
-            const ids = ['id-1', 'id-2'];
-            const mockDataList = [testData, { ...testData, _id: 'id-2' }];
-            mockDBService.find.and.returnValue(Promise.resolve(mockDataList));
-            const result = await service.getDataByIds(ids);
-            expect(result).toEqual(mockDataList);
-            expect(mockDBService.find).toHaveBeenCalledWith({ _id: { $in: ids } });
-        });
-        it('| should throw error when ids is missing', async () => {
-            await expectAsync(service.getDataByIds(null)).toBeRejected();
-        });
-        it('| should return empty array when ids is empty array', async () => {
-            const result = await service.getDataByIds([]);
-            expect(result).toEqual([]);
-        });
-    });
-    describe('| getDataListByIds', () => {
-        it('| should get data list by ids', async () => {
-            const ids = ['id-1', 'id-2'];
-            const mockDataList = [testData, { ...testData, _id: 'id-2' }];
-            mockDBService.getDataListByIds.and.returnValue(Promise.resolve(mockDataList));
-            const result = await service.getDataListByIds(ids);
-            expect(result).toEqual(mockDataList);
-            expect(service.dataList).toEqual(mockDataList);
-        });
-    });
-    describe('| getDataByDependencyId', () => {
-        it('| should get data by dependency id', async () => {
-            const dependencyData = { ...testData, userId: 'user-123' };
-            mockDBService.getDataByDependencyId.and.returnValue(Promise.resolve(dependencyData));
-            const result = await service.getDataByDependencyId('user-123');
-            expect(result).toBe(dependencyData);
-            expect(service.data).toBe(dependencyData);
-        });
-        it('| should throw error when dependency settings not configured', async () => {
-            const serviceWithoutDeps = new data_service_1.DyNTS_DataService(testData, new fsm_dynamo_1.DyFM_DataModel_Params({
-                dataName: 'test_data',
-                properties: { name: { key: 'name', type: fsm_dynamo_1.DyFM_BasicProperty_Type.string } },
-            }), 'test-issuer');
-            await expectAsync(serviceWithoutDeps.getDataByDependencyId('user-123')).toBeRejected();
-        });
-    });
-    describe('| findData', () => {
-        it('| should find data by filter', async () => {
-            const filter = { email: 'test@example.com' };
-            mockDBService.findOne.and.returnValue(Promise.resolve(testData));
-            const result = await service.findData(filter);
-            expect(result).toBe(testData);
-            expect(service.data).toBe(testData);
-            expect(mockDBService.findOne).toHaveBeenCalledWith(filter);
-        });
-    });
-    describe('| findDataList', () => {
-        it('| should find data list by filter', async () => {
-            const filter = { name: 'Test' };
-            const mockDataList = [testData];
-            mockDBService.find.and.returnValue(Promise.resolve(mockDataList));
-            const result = await service.findDataList(filter);
-            expect(result).toEqual(mockDataList);
-            expect(service.dataList).toEqual(mockDataList);
-        });
-        // FR-258 / SR-3 — over-fetch guard (unbounded find → heap → OOM precursor). Warns, never caps.
-        describe('| over-fetch warning (FR-258 / SR-3)', () => {
-            let originalThreshold;
-            beforeEach(() => {
-                originalThreshold = data_service_1.DyNTS_DataService.findDataListWarnThreshold;
-            });
-            afterEach(() => {
-                data_service_1.DyNTS_DataService.findDataListWarnThreshold = originalThreshold;
-            });
-            function listOf(count) {
-                return Array.from({ length: count }, (_v, i) => new TestMetadata({ _id: `id-${i}`, name: `n-${i}` }));
-            }
-            it('| warns when the result EXCEEDS the threshold', async () => {
-                data_service_1.DyNTS_DataService.findDataListWarnThreshold = 3;
-                const warnSpy = spyOn(fsm_dynamo_1.DyFM_Log, 'warn');
-                mockDBService.find.and.returnValue(Promise.resolve(listOf(5)));
-                const result = await service.findDataList({ name: 'Test' });
-                expect(result.length).toBe(5);
-                const overFetchCall = warnSpy.calls.allArgs().find((args) => typeof args[0] === 'string' && args[0].includes('[FR-258 SR-3]'));
-                expect(overFetchCall).toBeDefined();
-            });
-            it('| does NOT warn at exactly the threshold (strictly greater)', async () => {
-                data_service_1.DyNTS_DataService.findDataListWarnThreshold = 5;
-                const warnSpy = spyOn(fsm_dynamo_1.DyFM_Log, 'warn');
-                mockDBService.find.and.returnValue(Promise.resolve(listOf(5)));
-                await service.findDataList({ name: 'Test' });
-                const overFetchCall = warnSpy.calls.allArgs().find((args) => typeof args[0] === 'string' && args[0].includes('[FR-258 SR-3]'));
-                expect(overFetchCall).toBeUndefined();
-            });
-            it('| disabled (threshold <= 0) → never warns regardless of size', async () => {
-                data_service_1.DyNTS_DataService.findDataListWarnThreshold = 0;
-                const warnSpy = spyOn(fsm_dynamo_1.DyFM_Log, 'warn');
-                mockDBService.find.and.returnValue(Promise.resolve(listOf(50000)));
-                await service.findDataList({ name: 'Test' });
-                const overFetchCall = warnSpy.calls.allArgs().find((args) => typeof args[0] === 'string' && args[0].includes('[FR-258 SR-3]'));
-                expect(overFetchCall).toBeUndefined();
-            });
-        });
-    });
-    describe('| updateData', () => {
-        it('| should update data by filterBy', async () => {
-            const filter = { email: 'test@example.com' };
-            const update = { name: 'Updated Name' };
-            mockDBService.updateOne.and.returnValue(Promise.resolve());
-            await service.updateData({ filterBy: filter, update });
-            expect(mockDBService.updateOne).toHaveBeenCalledWith(filter, update, 'test-issuer', undefined);
-        });
-        it('| should update data by data._id', async () => {
-            const update = { name: 'Updated Name' };
-            mockDBService.updateOne.and.returnValue(Promise.resolve());
-            await service.updateData({ update });
-            expect(mockDBService.updateOne).toHaveBeenCalledWith({ _id: 'test-id-123' }, update, 'test-issuer', undefined);
-        });
-        it('| should throw error when no usable parameter provided', async () => {
-            service.data = new TestMetadata({});
-            const update = { name: 'Updated Name' };
-            await expectAsync(service.updateData({ update })).toBeRejected();
-        });
-    });
-    describe('| saveData', () => {
-        it('| should modify existing data when _id is present', async () => {
-            const existingData = { ...testData, name: 'Updated Name' };
-            mockDBService.getDataById.and.returnValue(Promise.resolve(testData));
-            mockDBService.modifyData.and.returnValue(Promise.resolve(existingData));
-            spyOn(service, 'validateForSave').and.returnValue(Promise.resolve());
-            const result = await service.saveData(existingData);
-            expect(result).toBe(existingData);
-            expect(mockDBService.modifyData).toHaveBeenCalled();
-        });
-        it('| should throw error when data with _id does not exist', async () => {
-            const dataWithId = { ...testData, _id: 'non-existent-id' };
-            mockDBService.getDataById.and.returnValue(Promise.resolve(null));
-            spyOn(service, 'validateForSave').and.returnValue(Promise.resolve());
-            await expectAsync(service.saveData(dataWithId)).toBeRejected();
-        });
-    });
-    describe('| deleteData', () => {
-        it('| should delete data by id', async () => {
-            mockDBService.getDataById.and.returnValue(Promise.resolve(testData));
-            mockDBService.markDeletedById.and.returnValue(Promise.resolve());
-            await service.deleteData('test-id-123');
-            expect(mockDBService.markDeletedById).toHaveBeenCalledWith('test-id-123', 'test-issuer');
-        });
-        it('| should use data._id when id not provided', async () => {
-            mockDBService.getDataById.and.returnValue(Promise.resolve(testData));
-            mockDBService.markDeletedById.and.returnValue(Promise.resolve());
-            await service.deleteData();
-            expect(mockDBService.markDeletedById).toHaveBeenCalledWith('test-id-123', 'test-issuer');
-        });
-        it('| should throw error when id is missing', async () => {
-            service.data = new TestMetadata({});
-            await expectAsync(service.deleteData()).toBeRejected();
-        });
-        it('| should archive data when archive service enabled', async () => {
-            service.haveArchiveDataService = true;
-            mockDBService.getDataById.and.returnValue(Promise.resolve(testData));
-            mockDBService.trueDeleteDataById.and.returnValue(Promise.resolve());
-            const mockArchiveService = jasmine.createSpyObj('DyNTS_ArchiveDataService', ['saveData']);
-            mockArchiveService.saveData.and.returnValue(Promise.resolve());
-            spyOn(service, 'getArchiveDataService').and.returnValue(mockArchiveService);
-            await service.deleteData('test-id-123');
-            expect(mockDBService.trueDeleteDataById).toHaveBeenCalled();
-            expect(mockArchiveService.saveData).toHaveBeenCalled();
-        });
-        it('| should permanently delete when absolute is true', async () => {
-            mockDBService.getDataById.and.returnValue(Promise.resolve(testData));
-            mockDBService.trueDeleteDataById.and.returnValue(Promise.resolve());
-            await service.deleteData('test-id-123', true);
-            expect(mockDBService.trueDeleteDataById).toHaveBeenCalledWith('test-id-123');
-        });
-    });
-    describe('| deleteAllData', () => {
-        it('| should delete all data', async () => {
-            const mockDataList = [testData, { ...testData, _id: 'id-2' }];
-            mockDBService.getAll.and.returnValue(Promise.resolve(mockDataList));
-            mockDBService.markDeletedById.and.returnValue(Promise.resolve());
-            await service.deleteAllData();
-            expect(mockDBService.markDeletedById).toHaveBeenCalledTimes(2);
-        });
-        it('| should archive all data when archive service enabled', async () => {
-            service.haveArchiveDataService = true;
-            const mockDataList = [testData];
-            mockDBService.getAll.and.returnValue(Promise.resolve(mockDataList));
-            mockDBService.trueDeleteAllData.and.returnValue(Promise.resolve());
-            const mockArchiveService = jasmine.createSpyObj('DyNTS_ArchiveDataService', ['saveData']);
-            mockArchiveService.saveData.and.returnValue(Promise.resolve());
-            spyOn(service, 'getArchiveDataService').and.returnValue(mockArchiveService);
-            await service.deleteAllData();
-            expect(mockDBService.trueDeleteAllData).toHaveBeenCalled();
-            expect(mockArchiveService.saveData).toHaveBeenCalled();
-        });
-    });
-    describe('| searchData', () => {
-        it('| should search data with query', async () => {
-            const query = {
-                filterBy: { name: 'Test' },
-                page: 0,
-                pageSize: 10,
-                sortBy: [{ key: 'name', order: 1 }],
-            };
-            const mockDataList = [testData];
-            spyOn(service, 'sortAndFilterDataList').and.returnValue(Promise.resolve({
-                results: mockDataList,
-                totalItems: 1,
-            }));
-            const result = await service.searchData(query);
-            expect(result.results).toEqual(mockDataList);
-            expect(service.sortAndFilterDataList).toHaveBeenCalledWith(query, undefined);
-        });
-        it('| should apply pagination', async () => {
-            const query = {
-                page: 1,
-                pageSize: 2,
-            };
-            const mockResults = [
-                testData,
-                { ...testData, _id: 'id-2' },
-                { ...testData, _id: 'id-3' },
-            ];
-            spyOn(service, 'sortAndFilterDataList').and.returnValue(Promise.resolve({
-                results: mockResults,
-                totalItems: 3,
-            }));
-            const result = await service.searchData(query);
-            expect(result.results.length).toBe(1);
-            expect(result.results[0]._id).toBe('id-3');
-        });
-    });
-    describe('| getArchiveDataService', () => {
-        it('| should throw error when not implemented', () => {
-            expect(() => {
-                service.getArchiveDataService();
-            }).toThrow();
-        });
-    });
-    describe('| getDependencyDataDBService', () => {
-        it('| should get dependency DB service when configured', () => {
-            const depService = service.getDependencyDataDBService('user_data');
-            expect(depService).toBeDefined();
-        });
-        it('| should throw error when service key not set', () => {
-            const serviceWithoutDeps = new data_service_1.DyNTS_DataService(testData, new fsm_dynamo_1.DyFM_DataModel_Params({
-                dataName: 'test_data',
-                properties: { name: { key: 'name', type: fsm_dynamo_1.DyFM_BasicProperty_Type.string } },
-            }), 'test-issuer');
-            expect(() => {
-                serviceWithoutDeps.getDependencyDataDBService();
-            }).toThrow();
-        });
-    });
-    // ════════════════════════════════════════════════════════════════════════
-    // FR-001 — Generic compareData()
-    // ════════════════════════════════════════════════════════════════════════
-    describe('| compareData() — FR-001', () => {
-        let svc;
-        beforeEach(() => {
-            // Re-use existing TestMetadata + testDataParams.
-            const t = new TestMetadata();
-            svc = new data_service_1.DyNTS_DataService(t, testDataParams, 'test-issuer');
-        });
-        it('| equal POJO returns { result: "equal" } — sin changedFields', () => {
-            const a = Object.assign(new TestMetadata(), { name: 'alice', email: 'a@x' });
-            const b = Object.assign(new TestMetadata(), { name: 'alice', email: 'a@x' });
-            const r = svc.compareData(a, b);
-            expect(r.result).toBe('equal');
-            expect(r.changedFields).toBeUndefined();
-        });
-        it('| modified single field — changedFields tartalmazza azt', () => {
-            const a = Object.assign(new TestMetadata(), { name: 'alice', email: 'a@x' });
-            const b = Object.assign(new TestMetadata(), { name: 'bob', email: 'a@x' });
-            const r = svc.compareData(a, b);
-            expect(r.result).toBe('modified');
-            expect(r.changedFields).toEqual(['name']);
-        });
-        it('| modified multi-field — changedFields TELJES listat ad (nem early-return)', () => {
-            const a = Object.assign(new TestMetadata(), { name: 'alice', email: 'a@x', userId: 'u1' });
-            const b = Object.assign(new TestMetadata(), { name: 'bob', email: 'b@y', userId: 'u2' });
-            const r = svc.compareData(a, b);
-            expect(r.result).toBe('modified');
-            expect(r.changedFields?.sort()).toEqual(['email', 'name', 'userId']);
-        });
-        it('| auto-discovery SKIP-eli a metadata fields-et (_id, __created, __lastModified)', () => {
-            const now = new Date();
-            const a = Object.assign(new TestMetadata(), { name: 'alice', _id: 'X', __created: now, __lastModified: now });
-            const b = Object.assign(new TestMetadata(), { name: 'alice', _id: 'Y', __created: new Date(2000, 0, 1), __lastModified: new Date(2001, 0, 1) });
-            const r = svc.compareData(a, b);
-            expect(r.result).toBe('equal');
-        });
-        it('| explicit fields override — KIFEJEZETT _id-val VIZSGALJA a skip-listet is', () => {
-            const a = Object.assign(new TestMetadata(), { name: 'alice', _id: 'X' });
-            const b = Object.assign(new TestMetadata(), { name: 'alice', _id: 'Y' });
-            const r = svc.compareData(a, b, { fields: ['_id'] });
-            expect(r.result).toBe('modified');
-            expect(r.changedFields).toEqual(['_id']);
-        });
-        it('| explicit fields scope-szukit — csak a listazott fields szamit', () => {
-            const a = Object.assign(new TestMetadata(), { name: 'alice', email: 'a@x' });
-            const b = Object.assign(new TestMetadata(), { name: 'alice', email: 'b@y' });
-            const r = svc.compareData(a, b, { fields: ['name'] });
-            expect(r.result).toBe('equal'); // email change ignored, only 'name' checked
-        });
-        it('| customComparator override (case-insensitive string)', () => {
-            const a = Object.assign(new TestMetadata(), { name: 'Alice' });
-            const b = Object.assign(new TestMetadata(), { name: 'alice' });
-            const r = svc.compareData(a, b, {
-                customComparators: { name: (x, y) => x.toLowerCase() === y.toLowerCase() },
-            });
-            expect(r.result).toBe('equal');
-        });
-        it('| customComparator — array-set-equality eltero sorrendre', () => {
-            class WithArr extends fsm_dynamo_1.DyFM_Metadata {
-                name;
-                tags;
-            }
-            const arrSvc = new data_service_1.DyNTS_DataService(new WithArr(), new fsm_dynamo_1.DyFM_DataModel_Params({
-                dataName: 'with_arr',
-                properties: { name: { key: 'name', type: fsm_dynamo_1.DyFM_BasicProperty_Type.string } },
-            }), 'test-issuer');
-            const a = Object.assign(new WithArr(), { name: 'x', tags: ['a', 'b', 'c'] });
-            const b = Object.assign(new WithArr(), { name: 'x', tags: ['c', 'b', 'a'] });
-            const r = arrSvc.compareData(a, b, {
-                customComparators: {
-                    tags: (x, y) => {
-                        const s = new Set(x);
-                        return y.length === x.length && y.every((v) => s.has(v));
-                    },
-                },
-            });
-            expect(r.result).toBe('equal');
-        });
-        it('| deep-equal: Date instances ugyanazon time-stamp-pel equal-nek szamitanak', () => {
-            class WithDate extends fsm_dynamo_1.DyFM_Metadata {
-                when;
-            }
-            const dateSvc = new data_service_1.DyNTS_DataService(new WithDate(), new fsm_dynamo_1.DyFM_DataModel_Params({
-                dataName: 'with_date',
-                properties: {},
-            }), 'test-issuer');
-            const t = 1_700_000_000_000;
-            const a = Object.assign(new WithDate(), { when: new Date(t) });
-            const b = Object.assign(new WithDate(), { when: new Date(t) });
-            expect(dateSvc.compareData(a, b).result).toBe('equal');
-        });
-        it('| deep-equal: nested object', () => {
-            class WithNested extends fsm_dynamo_1.DyFM_Metadata {
-                nested;
-            }
-            const nSvc = new data_service_1.DyNTS_DataService(new WithNested(), new fsm_dynamo_1.DyFM_DataModel_Params({ dataName: 'with_nested', properties: {} }), 'test-issuer');
-            const a = Object.assign(new WithNested(), { nested: { a: 1, b: { c: 'x' } } });
-            const b = Object.assign(new WithNested(), { nested: { a: 1, b: { c: 'x' } } });
-            const c = Object.assign(new WithNested(), { nested: { a: 1, b: { c: 'y' } } });
-            expect(nSvc.compareData(a, b).result).toBe('equal');
-            expect(nSvc.compareData(a, c).result).toBe('modified');
-        });
-        it('| deep-equal: array index-szerinti compare (eltero sorrend → modified default-ban)', () => {
-            class WithArr2 extends fsm_dynamo_1.DyFM_Metadata {
-                items;
-            }
-            const aSvc = new data_service_1.DyNTS_DataService(new WithArr2(), new fsm_dynamo_1.DyFM_DataModel_Params({ dataName: 'with_arr2', properties: {} }), 'test-issuer');
-            const a = Object.assign(new WithArr2(), { items: [1, 2, 3] });
-            const b = Object.assign(new WithArr2(), { items: [1, 2, 3] });
-            const c = Object.assign(new WithArr2(), { items: [3, 2, 1] });
-            expect(aSvc.compareData(a, b).result).toBe('equal');
-            expect(aSvc.compareData(a, c).result).toBe('modified');
-        });
-        it('| throw 400 ha newData null', () => {
-            const b = Object.assign(new TestMetadata(), { name: 'x' });
-            let thrown = null;
-            try {
-                svc.compareData(null, b);
-            }
-            catch (e) {
-                thrown = e;
-            }
-            expect(thrown).not.toBeNull();
-            expect(fsm_dynamo_1.DyFM_Error.getErrorStatus(thrown)).toBe(400);
-            expect(fsm_dynamo_1.DyFM_Error.getErrorCode(thrown)).toContain('DyNTS-DS0-CD1');
-        });
-        it('| throw 400 ha oldData undefined', () => {
-            const a = Object.assign(new TestMetadata(), { name: 'x' });
-            let thrown = null;
-            try {
-                svc.compareData(a, undefined);
-            }
-            catch (e) {
-                thrown = e;
-            }
-            expect(thrown).not.toBeNull();
-            expect(fsm_dynamo_1.DyFM_Error.getErrorStatus(thrown)).toBe(400);
-        });
-        it('| throw 400 ha options.fields ures array', () => {
-            const a = Object.assign(new TestMetadata(), { name: 'alice' });
-            const b = Object.assign(new TestMetadata(), { name: 'alice' });
-            let thrown = null;
-            try {
-                svc.compareData(a, b, { fields: [] });
-            }
-            catch (e) {
-                thrown = e;
-            }
-            expect(thrown).not.toBeNull();
-            expect(fsm_dynamo_1.DyFM_Error.getErrorStatus(thrown)).toBe(400);
-            expect(fsm_dynamo_1.DyFM_Error.getErrorCode(thrown)).toContain('DyNTS-DS0-CD2');
-        });
-        it('| asymmetric keys: ha az egyik objektum-bol hianyzik a key, modified-nek szamit', () => {
-            const a = Object.assign(new TestMetadata(), { name: 'alice', email: 'a@x' });
-            const b = Object.assign(new TestMetadata(), { name: 'alice' }); // no email
-            const r = svc.compareData(a, b);
-            expect(r.result).toBe('modified');
-            expect(r.changedFields).toEqual(['email']);
-        });
-    });
-    /**
-     * BFR-FDPTOKENSERVICE-011 — a validátor tömb-ága: egy OPCIONÁLIS `X[]`+`subObjectParams` mező
-     * `undefined` értéke (a normál „még nincs elem" eset) NEM szállhat el `forEach`-TypeError-ral.
-     * A required-hiányt a VP8-ág fogja — az `Array.isArray` őr nem gyengít semmit.
-     */
-    describe('| validateForSave — opcionális tömb-mező subObjectParams-szal (BFR-FDPTOKENSERVICE-011)', () => {
-        class WithOptArr extends fsm_dynamo_1.DyFM_Metadata {
-            name;
-            invoices;
-        }
-        const buildParams = (required) => new fsm_dynamo_1.DyFM_DataModel_Params({
-            dataName: 'with_opt_arr',
-            properties: {
-                invoices: {
-                    key: 'invoices',
-                    type: fsm_dynamo_1.DyFM_BasicProperty_Type.array,
-                    required: required,
-                    subObjectParams: {
-                        num: { key: 'num', type: fsm_dynamo_1.DyFM_BasicProperty_Type.string, required: true },
-                    },
-                },
-            },
-        });
-        it('| undefined opcionális tömb → NEM dob (a mentés nem bukhat a hiányzó elemeken)', async () => {
-            const optSvc = new data_service_1.DyNTS_DataService(Object.assign(new WithOptArr(), { name: 'x' }), buildParams(false), 'test-issuer');
-            await expectAsync(optSvc.validateForSave()).toBeResolved();
-        });
-        it('| tényleges tömbnél a sub-validáció VÁLTOZATLANUL fut (required sub-mező hiánya → 400)', async () => {
-            const optSvc = new data_service_1.DyNTS_DataService(Object.assign(new WithOptArr(), { name: 'x', invoices: [{}] }), buildParams(false), 'test-issuer');
-            let thrown = null;
-            try {
-                await optSvc.validateForSave();
-            }
-            catch (e) {
-                thrown = e;
-            }
-            expect(thrown).not.toBeNull();
-            expect(fsm_dynamo_1.DyFM_Error.getErrorStatus(thrown)).toBe(400);
-        });
-        it('| required tömb hiánya továbbra is validációs 400 (az őr nem gyengít; hiányra a VP1 required-ág fut)', async () => {
-            const reqSvc = new data_service_1.DyNTS_DataService(Object.assign(new WithOptArr(), { name: 'x' }), buildParams(true), 'test-issuer');
-            let thrown = null;
-            try {
-                await reqSvc.validateForSave();
-            }
-            catch (e) {
-                thrown = e;
-            }
-            expect(thrown).not.toBeNull();
-            expect(fsm_dynamo_1.DyFM_Error.getErrorStatus(thrown)).toBe(400);
-            expect(fsm_dynamo_1.DyFM_Error.getErrorCode(thrown)).toContain('DyNTS-DS0-VP');
-        });
-    });
-});
-//# sourceMappingURL=data.service.spec.js.map