tm1npm 1.5.3 → 2.0.0

package/lib/tests/elementService.issue38.test.js

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * ElementService Tests — Issue #38 new methods
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const ElementService_1 = require("../services/ElementService");
+const ElementAttribute_1 = require("../objects/ElementAttribute");
+const createMockResponse = (data, status = 200) => ({
+    data,
+    status,
+    statusText: status === 200 ? 'OK' : status === 201 ? 'Created' : status === 204 ? 'No Content' : 'Error',
+    headers: {},
+    config: {}
+});
+describe('ElementService — Issue #38 new methods', () => {
+    let elementService;
+    let mockRestService;
+    beforeEach(() => {
+        mockRestService = {
+            get: jest.fn(),
+            post: jest.fn(),
+            patch: jest.fn(),
+            delete: jest.fn(),
+            put: jest.fn(),
+            config: {},
+            rest: {},
+            buildBaseUrl: jest.fn(),
+            extractErrorMessage: jest.fn()
+        };
+        elementService = new ElementService_1.ElementService(mockRestService);
+    });
+    // ===== addElementAttributes =====
+    describe('addElementAttributes', () => {
+        test('should POST to ElementAttributes endpoint with correct body', async () => {
+            mockRestService.post.mockResolvedValue(createMockResponse({}, 201));
+            const attrs = [
+                new ElementAttribute_1.ElementAttribute('Description', 'String'),
+                new ElementAttribute_1.ElementAttribute('Score', 'Numeric')
+            ];
+            await elementService.addElementAttributes('TestDimension', 'TestHierarchy', attrs);
+            expect(mockRestService.post).toHaveBeenCalledTimes(1);
+            const [url, body] = mockRestService.post.mock.calls[0];
+            expect(url).toContain("Dimensions('TestDimension')/Hierarchies('TestHierarchy')/ElementAttributes");
+            const parsed = JSON.parse(body);
+            expect(Array.isArray(parsed)).toBe(true);
+            expect(parsed).toHaveLength(2);
+            expect(parsed[0].Name).toBe('Description');
+            expect(parsed[0].Type).toBe('String');
+            expect(parsed[1].Name).toBe('Score');
+            expect(parsed[1].Type).toBe('Numeric');
+        });
+        test('should POST an empty array when no attributes provided', async () => {
+            mockRestService.post.mockResolvedValue(createMockResponse({}, 201));
+            await elementService.addElementAttributes('TestDimension', 'TestHierarchy', []);
+            expect(mockRestService.post).toHaveBeenCalledTimes(1);
+            const [, body] = mockRestService.post.mock.calls[0];
+            const parsed = JSON.parse(body);
+            expect(parsed).toEqual([]);
+        });
+        test('should POST a single attribute', async () => {
+            mockRestService.post.mockResolvedValue(createMockResponse({}, 201));
+            const attrs = [new ElementAttribute_1.ElementAttribute('Alias', 'Alias')];
+            await elementService.addElementAttributes('Dim', 'Hier', attrs);
+            const [, body] = mockRestService.post.mock.calls[0];
+            const parsed = JSON.parse(body);
+            expect(parsed).toHaveLength(1);
+            expect(parsed[0].Name).toBe('Alias');
+            expect(parsed[0].Type).toBe('Alias');
+        });
+        test('should include dimension and hierarchy names in the URL', async () => {
+            mockRestService.post.mockResolvedValue(createMockResponse({}, 201));
+            await elementService.addElementAttributes('MyDimension', 'MyHierarchy', [new ElementAttribute_1.ElementAttribute('Attr1', 'String')]);
+            const [url] = mockRestService.post.mock.calls[0];
+            expect(url).toContain("MyDimension");
+            expect(url).toContain("MyHierarchy");
+        });
+    });
+});
+//# sourceMappingURL=elementService.issue38.test.js.map

package/lib/tests/hierarchyService.issue38.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * HierarchyService Tests — Issue #38 new methods
+ */
+export {};
+//# sourceMappingURL=hierarchyService.issue38.test.d.ts.map

package/lib/tests/hierarchyService.issue38.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hierarchyService.issue38.test.d.ts","sourceRoot":"","sources":["../../src/tests/hierarchyService.issue38.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/lib/tests/hierarchyService.issue38.test.js

@@ -0,0 +1,460 @@
+"use strict";
+/**
+ * HierarchyService Tests — Issue #38 new methods
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const HierarchyService_1 = require("../services/HierarchyService");
+const Hierarchy_1 = require("../objects/Hierarchy");
+const Element_1 = require("../objects/Element");
+const ElementAttribute_1 = require("../objects/ElementAttribute");
+const TM1Exception_1 = require("../exceptions/TM1Exception");
+const DataFrame_1 = require("../utils/DataFrame");
+const createMockResponse = (data, status = 200) => ({
+    data,
+    status,
+    statusText: status === 200 ? 'OK' : status === 201 ? 'Created' : status === 204 ? 'No Content' : 'Error',
+    headers: {},
+    config: {}
+});
+describe('HierarchyService — Issue #38 new methods', () => {
+    let hierarchyService;
+    let mockRestService;
+    beforeEach(() => {
+        mockRestService = {
+            get: jest.fn(),
+            post: jest.fn(),
+            patch: jest.fn(),
+            delete: jest.fn(),
+            put: jest.fn(),
+            config: {},
+            rest: {},
+            buildBaseUrl: jest.fn(),
+            extractErrorMessage: jest.fn()
+        };
+        hierarchyService = new HierarchyService_1.HierarchyService(mockRestService);
+    });
+    // ===== updateOrCreate =====
+    describe('updateOrCreate', () => {
+        test('should call create when hierarchy does not exist', async () => {
+            const hierarchy = new Hierarchy_1.Hierarchy('NewHierarchy', 'TestDimension');
+            // exists() does a GET for $select=Name — return list without the hierarchy
+            mockRestService.get.mockImplementation(async (url) => {
+                if (url.includes('$select=Name')) {
+                    return createMockResponse({ value: [] });
+                }
+                // getElementAttributes inside create -> updateElementAttributes
+                return createMockResponse({ value: [] });
+            });
+            mockRestService.post.mockResolvedValue(createMockResponse({ Name: 'NewHierarchy' }, 201));
+            const result = await hierarchyService.updateOrCreate(hierarchy);
+            expect(mockRestService.post).toHaveBeenCalledTimes(1);
+            const postUrl = mockRestService.post.mock.calls[0][0];
+            expect(postUrl).toContain("/Hierarchies");
+        });
+        test('should call update when hierarchy exists', async () => {
+            const hierarchy = new Hierarchy_1.Hierarchy('ExistingHierarchy', 'TestDimension');
+            // exists() returns the hierarchy in the list
+            mockRestService.get.mockImplementation(async (url) => {
+                if (url.includes('$select=Name')) {
+                    return createMockResponse({ value: [{ Name: 'ExistingHierarchy' }] });
+                }
+                // getElementAttributes inside update -> updateElementAttributes
+                return createMockResponse({ value: [] });
+            });
+            mockRestService.patch.mockResolvedValue(createMockResponse({}, 200));
+            const result = await hierarchyService.updateOrCreate(hierarchy);
+            expect(mockRestService.patch).toHaveBeenCalledTimes(1);
+            const patchUrl = mockRestService.patch.mock.calls[0][0];
+            expect(patchUrl).toContain("Hierarchies('ExistingHierarchy')");
+        });
+    });
+    // ===== getHierarchySummary =====
+    describe('getHierarchySummary', () => {
+        test('should return correct counts from OData response', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                'Cardinality': 0,
+                'Elements@odata.count': 42,
+                'Edges@odata.count': 30,
+                'ElementAttributes@odata.count': 5,
+                'Members@odata.count': 50,
+                'Levels@odata.count': 3
+            }));
+            const summary = await hierarchyService.getHierarchySummary('TestDimension', 'TestHierarchy');
+            expect(summary.Elements).toBe(42);
+            expect(summary.Edges).toBe(30);
+            expect(summary.ElementAttributes).toBe(5);
+            expect(summary.Members).toBe(50);
+            expect(summary.Levels).toBe(3);
+        });
+        test('should default hierarchyName to dimensionName when not provided', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                'Elements@odata.count': 10,
+                'Edges@odata.count': 5,
+                'ElementAttributes@odata.count': 2,
+                'Members@odata.count': 10,
+                'Levels@odata.count': 1
+            }));
+            await hierarchyService.getHierarchySummary('TestDimension');
+            const calledUrl = mockRestService.get.mock.calls[0][0];
+            expect(calledUrl).toContain("Hierarchies('TestDimension')");
+        });
+        test('should default missing odata counts to 0', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({}));
+            const summary = await hierarchyService.getHierarchySummary('TestDimension', 'TestHierarchy');
+            expect(summary.Elements).toBe(0);
+            expect(summary.Edges).toBe(0);
+            expect(summary.ElementAttributes).toBe(0);
+            expect(summary.Members).toBe(0);
+            expect(summary.Levels).toBe(0);
+        });
+    });
+    // ===== getDefaultMember =====
+    describe('getDefaultMember', () => {
+        test('should return member name from response', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({ Name: 'All Members' }));
+            const result = await hierarchyService.getDefaultMember('TestDimension', 'TestHierarchy');
+            expect(result).toBe('All Members');
+            const calledUrl = mockRestService.get.mock.calls[0][0];
+            expect(calledUrl).toContain('/DefaultMember');
+        });
+        test('should return null on 404', async () => {
+            mockRestService.get.mockRejectedValue(new TM1Exception_1.TM1RestException('Not found', 404, { status: 404 }));
+            const result = await hierarchyService.getDefaultMember('TestDimension', 'TestHierarchy');
+            expect(result).toBeNull();
+        });
+        test('should rethrow non-404 errors', async () => {
+            mockRestService.get.mockRejectedValue(new TM1Exception_1.TM1RestException('Server error', 500, { status: 500 }));
+            await expect(hierarchyService.getDefaultMember('TestDimension', 'TestHierarchy')).rejects.toThrow();
+        });
+        test('should default hierarchyName to dimensionName', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({ Name: 'Root' }));
+            await hierarchyService.getDefaultMember('TestDimension');
+            const calledUrl = mockRestService.get.mock.calls[0][0];
+            expect(calledUrl).toContain("Hierarchies('TestDimension')");
+        });
+    });
+    // ===== updateDefaultMember =====
+    describe('updateDefaultMember', () => {
+        test('should use API approach (PATCH) when version is 12.0.0', async () => {
+            mockRestService.version = '12.0.0';
+            mockRestService.patch.mockResolvedValue(createMockResponse({}, 200));
+            await hierarchyService.updateDefaultMember('TestDimension', 'TestHierarchy', 'RootMember');
+            expect(mockRestService.patch).toHaveBeenCalledTimes(1);
+            const [url, body] = mockRestService.patch.mock.calls[0];
+            expect(url).toContain("Dimensions('TestDimension')/Hierarchies('TestHierarchy')");
+            const parsed = JSON.parse(body);
+            expect(parsed['DefaultMember@odata.bind']).toContain("Elements('RootMember')");
+        });
+        test('should use API approach when version is undefined', async () => {
+            mockRestService.version = undefined;
+            mockRestService.patch.mockResolvedValue(createMockResponse({}, 200));
+            await hierarchyService.updateDefaultMember('TestDimension', 'TestHierarchy', 'RootMember');
+            expect(mockRestService.patch).toHaveBeenCalledTimes(1);
+        });
+        test('should use props cube approach for pre-v12 (version 11.8.0)', async () => {
+            mockRestService.version = '11.8.0';
+            // CellService.writeValue calls getDimensionNamesForWriting (GET) then POST
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                Dimensions: [
+                    { Name: '}HierarchyProperties' },
+                    { Name: '}HierarchyProperties_dim' },
+                    { Name: 'MEMBER_DEFAULT' }
+                ]
+            }));
+            mockRestService.post.mockResolvedValue(createMockResponse({}, 200));
+            await hierarchyService.updateDefaultMember('TestDimension', 'TestHierarchy', 'RootMember');
+            expect(mockRestService.post).toHaveBeenCalledTimes(1);
+            const [url, body] = mockRestService.post.mock.calls[0];
+            // The cube name '}HierarchyProperties' gets URL-encoded as '%7DHierarchyProperties'
+            expect(url).toContain('HierarchyProperties');
+            const parsed = JSON.parse(body);
+            expect(parsed.Cells[0].Value).toBe('RootMember');
+        });
+        test('should clear default member when memberName is empty string (API approach)', async () => {
+            mockRestService.version = '12.0.0';
+            mockRestService.patch.mockResolvedValue(createMockResponse({}, 200));
+            await hierarchyService.updateDefaultMember('TestDimension', 'TestHierarchy', '');
+            expect(mockRestService.patch).toHaveBeenCalledTimes(1);
+            const [, body] = mockRestService.patch.mock.calls[0];
+            const parsed = JSON.parse(body);
+            expect(parsed['DefaultMember@odata.bind']).toBeNull();
+        });
+        test('should default hierarchyName to dimensionName', async () => {
+            mockRestService.version = '12.0.0';
+            mockRestService.patch.mockResolvedValue(createMockResponse({}, 200));
+            await hierarchyService.updateDefaultMember('TestDimension', undefined, 'Root');
+            const [url] = mockRestService.patch.mock.calls[0];
+            expect(url).toContain("Hierarchies('TestDimension')");
+        });
+    });
+    // ===== removeEdgesUnderConsolidation =====
+    describe('removeEdgesUnderConsolidation', () => {
+        test('should remove edges under the specified consolidation element', async () => {
+            // Build a hierarchy: Total -> [A, B], A -> [A1, A2]
+            const hierarchy = new Hierarchy_1.Hierarchy('TestHierarchy', 'TestDimension');
+            hierarchy.addEdge('Total', 'A', 1);
+            hierarchy.addEdge('Total', 'B', 1);
+            hierarchy.addEdge('A', 'A1', 1);
+            hierarchy.addEdge('A', 'A2', 1);
+            let getCallCount = 0;
+            mockRestService.get.mockImplementation(async (url) => {
+                getCallCount++;
+                if (getCallCount === 1) {
+                    // First call is the get(dimensionName, hierarchyName) inside removeEdgesUnderConsolidation
+                    return createMockResponse({
+                        Name: 'TestHierarchy',
+                        Elements: [
+                            { Name: 'Total', Type: 'Consolidated' },
+                            { Name: 'A', Type: 'Consolidated' },
+                            { Name: 'B', Type: 'Numeric' },
+                            { Name: 'A1', Type: 'Numeric' },
+                            { Name: 'A2', Type: 'Numeric' }
+                        ],
+                        Edges: [
+                            { ParentName: 'Total', ComponentName: 'A', Weight: 1 },
+                            { ParentName: 'Total', ComponentName: 'B', Weight: 1 },
+                            { ParentName: 'A', ComponentName: 'A1', Weight: 1 },
+                            { ParentName: 'A', ComponentName: 'A2', Weight: 1 }
+                        ],
+                        ElementAttributes: [],
+                        Subsets: []
+                    });
+                }
+                // Subsequent calls from updateElementAttributes
+                return createMockResponse({ value: [] });
+            });
+            mockRestService.patch.mockResolvedValue(createMockResponse({}, 200));
+            await hierarchyService.removeEdgesUnderConsolidation('TestDimension', 'TestHierarchy', 'A');
+            expect(mockRestService.patch).toHaveBeenCalledTimes(1);
+            const [, body] = mockRestService.patch.mock.calls[0];
+            const parsed = JSON.parse(body);
+            // After removing edges under A, A should have no children in the hierarchy
+            const remainingEdges = parsed.Edges || [];
+            const aEdges = remainingEdges.filter((e) => e.ParentName === 'A');
+            expect(aEdges).toHaveLength(0);
+        });
+    });
+    // ===== addEdges =====
+    describe('addEdges', () => {
+        test('should delegate to ElementService.addEdges', async () => {
+            mockRestService.post.mockResolvedValue(createMockResponse({}, 201));
+            await hierarchyService.addEdges('TestDimension', 'TestHierarchy', { Parent: { Child: 1 } });
+            expect(mockRestService.post).toHaveBeenCalledTimes(1);
+            const [url] = mockRestService.post.mock.calls[0];
+            expect(url).toContain("Dimensions('TestDimension')/Hierarchies('TestHierarchy')");
+        });
+        test('should use dimensionName as hierarchyName when hierarchyName is undefined', async () => {
+            mockRestService.post.mockResolvedValue(createMockResponse({}, 201));
+            await hierarchyService.addEdges('TestDimension', undefined, { P: { C: 1 } });
+            const [url] = mockRestService.post.mock.calls[0];
+            expect(url).toContain("Hierarchies('TestDimension')");
+        });
+    });
+    // ===== addElements =====
+    describe('addElements', () => {
+        test('should delegate to ElementService.addElements', async () => {
+            mockRestService.post.mockResolvedValue(createMockResponse({}, 201));
+            const elements = [new Element_1.Element('Elem1', Element_1.ElementType.NUMERIC)];
+            await hierarchyService.addElements('TestDimension', 'TestHierarchy', elements);
+            expect(mockRestService.post).toHaveBeenCalledTimes(1);
+            const [url] = mockRestService.post.mock.calls[0];
+            expect(url).toContain("Dimensions('TestDimension')/Hierarchies('TestHierarchy')/Elements");
+        });
+    });
+    // ===== addElementAttributes =====
+    describe('addElementAttributes', () => {
+        test('should delegate to ElementService.addElementAttributes', async () => {
+            mockRestService.post.mockResolvedValue(createMockResponse({}, 201));
+            const attrs = [new ElementAttribute_1.ElementAttribute('Description', 'String')];
+            await hierarchyService.addElementAttributes('TestDimension', 'TestHierarchy', attrs);
+            expect(mockRestService.post).toHaveBeenCalledTimes(1);
+            const [url] = mockRestService.post.mock.calls[0];
+            expect(url).toContain("Dimensions('TestDimension')/Hierarchies('TestHierarchy')/ElementAttributes");
+        });
+    });
+    // ===== updateOrCreateHierarchyFromDataframe =====
+    describe('updateOrCreateHierarchyFromDataframe', () => {
+        // Helper: mock hierarchy response with given elements/edges
+        const mockHierarchyResponse = (elements = [], edges = []) => createMockResponse({
+            Name: 'TestHierarchy',
+            Elements: elements,
+            Edges: edges,
+            ElementAttributes: [],
+            Subsets: [],
+            DefaultMember: null
+        });
+        // Helper: mock "hierarchy exists" check (getAllNames-style)
+        const setupExistingHierarchy = (elements = [], edges = []) => {
+            // exists() calls GET /Hierarchies?$select=Name
+            mockRestService.get.mockImplementation(async (url) => {
+                if (url.includes('$select=Name')) {
+                    return createMockResponse({ value: [{ Name: 'TestHierarchy' }] });
+                }
+                if (url.includes('$expand=Edges')) {
+                    return mockHierarchyResponse(elements, edges);
+                }
+                if (url.includes('ElementAttributes')) {
+                    return createMockResponse({ value: [] });
+                }
+                return createMockResponse({});
+            });
+        };
+        const setupNewHierarchy = () => {
+            let hierarchyCreated = false;
+            mockRestService.get.mockImplementation(async (url) => {
+                if (url.includes('$select=Name')) {
+                    return createMockResponse({ value: [] }); // hierarchy doesn't exist
+                }
+                if (url.includes('$expand=Edges')) {
+                    return mockHierarchyResponse(); // empty hierarchy after creation
+                }
+                if (url.includes('ElementAttributes')) {
+                    return createMockResponse({ value: [] });
+                }
+                return createMockResponse({});
+            });
+            mockRestService.post.mockImplementation(async (url, body) => {
+                hierarchyCreated = true;
+                return createMockResponse({}, 201);
+            });
+            mockRestService.patch.mockResolvedValue(createMockResponse({}, 200));
+        };
+        test('should add new elements from DataFrame to existing hierarchy', async () => {
+            setupExistingHierarchy([
+                { Name: 'Existing1', Type: 'Numeric' }
+            ]);
+            mockRestService.post.mockResolvedValue(createMockResponse({}, 201));
+            const df = new DataFrame_1.DataFrame([
+                ['Existing1', 'Numeric'],
+                ['NewElem1', 'String'],
+                ['NewElem2', 'Numeric']
+            ], { columns: ['Element', 'ElementType'] });
+            await hierarchyService.updateOrCreateHierarchyFromDataframe('TestDimension', 'TestHierarchy', df, { elementColumn: 'Element' });
+            // Should POST new elements (NewElem1, NewElem2 but not Existing1)
+            const postCalls = mockRestService.post.mock.calls;
+            const elementPostCall = postCalls.find(([url]) => url.includes('/Elements') && !url.includes('ElementAttributes'));
+            expect(elementPostCall).toBeDefined();
+            const postedBody = JSON.parse(elementPostCall[1]);
+            expect(postedBody).toHaveLength(2);
+            expect(postedBody.map((e) => e.Name).sort()).toEqual(['NewElem1', 'NewElem2']);
+        });
+        test('should throw on duplicate elements when verifyUniqueElements=true', async () => {
+            const df = new DataFrame_1.DataFrame([
+                ['Elem1', 'Numeric'],
+                ['elem1', 'String'], // duplicate (case-insensitive)
+            ], { columns: ['Element', 'ElementType'] });
+            await expect(hierarchyService.updateOrCreateHierarchyFromDataframe('TestDimension', 'TestHierarchy', df, { elementColumn: 'Element', verifyUniqueElements: true })).rejects.toThrow('Duplicate element');
+        });
+        test('should create dimension when hierarchy does not exist', async () => {
+            setupNewHierarchy();
+            const df = new DataFrame_1.DataFrame([
+                ['Elem1', 'Numeric']
+            ], { columns: ['Element', 'ElementType'] });
+            await hierarchyService.updateOrCreateHierarchyFromDataframe('NewDimension', 'NewHierarchy', df, { elementColumn: 'Element' });
+            // Should have called POST for dimension creation
+            const postCalls = mockRestService.post.mock.calls;
+            const dimCreateCall = postCalls.find(([url]) => url.includes('/Dimensions'));
+            expect(dimCreateCall).toBeDefined();
+        });
+        test('should unwind all edges when unwindAll=true', async () => {
+            setupExistingHierarchy([{ Name: 'Parent', Type: 'Consolidated' }, { Name: 'Child', Type: 'Numeric' }], [{ ParentName: 'Parent', ComponentName: 'Child', Weight: 1 }]);
+            mockRestService.post.mockResolvedValue(createMockResponse({}, 201));
+            mockRestService.patch.mockResolvedValue(createMockResponse({}, 200));
+            const df = new DataFrame_1.DataFrame([
+                ['Child', 'Numeric']
+            ], { columns: ['Element', 'ElementType'] });
+            await hierarchyService.updateOrCreateHierarchyFromDataframe('TestDimension', 'TestHierarchy', df, { elementColumn: 'Element', unwindAll: true });
+            // Should PATCH to remove all edges (empty Edges array)
+            const patchCalls = mockRestService.patch.mock.calls;
+            const edgePatch = patchCalls.find(([_, body]) => {
+                try {
+                    return JSON.parse(body).Edges !== undefined;
+                }
+                catch (_a) {
+                    return false;
+                }
+            });
+            expect(edgePatch).toBeDefined();
+        });
+        test('should re-throw unexpected errors from bulk edge add', async () => {
+            setupExistingHierarchy();
+            mockRestService.post.mockImplementation(async (url) => {
+                if (url.includes('/Edges')) {
+                    throw new TM1Exception_1.TM1RestException('Server error', 500, { status: 500 });
+                }
+                if (url.includes('/Elements')) {
+                    return createMockResponse({}, 201);
+                }
+                return createMockResponse({}, 201);
+            });
+            const df = new DataFrame_1.DataFrame([
+                ['Child', 'Numeric', 'Parent'],
+            ], { columns: ['Element', 'ElementType', 'Level001'] });
+            await expect(hierarchyService.updateOrCreateHierarchyFromDataframe('TestDimension', 'TestHierarchy', df, { elementColumn: 'Element' })).rejects.toThrow('Server error');
+        });
+        test('should fall back to individual edges on 400 from bulk', async () => {
+            setupExistingHierarchy();
+            let bulkAttempted = false;
+            mockRestService.post.mockImplementation(async (url, body) => {
+                if (url.includes('/Edges')) {
+                    if (!bulkAttempted) {
+                        bulkAttempted = true;
+                        throw new TM1Exception_1.TM1RestException('Bad request', 400, { status: 400 });
+                    }
+                    // Individual edge adds succeed
+                    return createMockResponse({}, 201);
+                }
+                if (url.includes('/Elements')) {
+                    return createMockResponse({}, 201);
+                }
+                return createMockResponse({}, 201);
+            });
+            const df = new DataFrame_1.DataFrame([
+                ['Child', 'Numeric', 'Parent'],
+            ], { columns: ['Element', 'ElementType', 'Level001'] });
+            await hierarchyService.updateOrCreateHierarchyFromDataframe('TestDimension', 'TestHierarchy', df, { elementColumn: 'Element' });
+            // Bulk failed, then individual edge was attempted
+            const edgeCalls = mockRestService.post.mock.calls.filter(([url]) => url.includes('/Edges'));
+            expect(edgeCalls.length).toBeGreaterThan(1); // bulk + individual
+        });
+        test('should delete orphaned consolidations when requested', async () => {
+            // Setup: hierarchy has a Consolidated element "Orphan" with no children
+            const getCallCount = { n: 0 };
+            mockRestService.get.mockImplementation(async (url) => {
+                if (url.includes('$select=Name')) {
+                    return createMockResponse({ value: [{ Name: 'TestHierarchy' }] });
+                }
+                if (url.includes('$expand=Edges')) {
+                    getCallCount.n++;
+                    // Return hierarchy with orphaned consolidation
+                    return createMockResponse({
+                        Name: 'TestHierarchy',
+                        Elements: [
+                            { Name: 'Leaf', Type: 'Numeric' },
+                            { Name: 'Orphan', Type: 'Consolidated' }
+                        ],
+                        Edges: [], // No edges — Orphan is orphaned
+                        ElementAttributes: [],
+                        Subsets: [],
+                        DefaultMember: null
+                    });
+                }
+                if (url.includes('ElementAttributes')) {
+                    return createMockResponse({ value: [] });
+                }
+                return createMockResponse({});
+            });
+            mockRestService.post.mockResolvedValue(createMockResponse({}, 201));
+            mockRestService.delete.mockResolvedValue(createMockResponse({}, 204));
+            const df = new DataFrame_1.DataFrame([
+                ['Leaf', 'Numeric']
+            ], { columns: ['Element', 'ElementType'] });
+            await hierarchyService.updateOrCreateHierarchyFromDataframe('TestDimension', 'TestHierarchy', df, { elementColumn: 'Element', deleteOrphanedConsolidations: true });
+            // Should DELETE the orphaned consolidation
+            const deleteCalls = mockRestService.delete.mock.calls;
+            const orphanDelete = deleteCalls.find(([url]) => url.includes("Elements('Orphan')"));
+            expect(orphanDelete).toBeDefined();
+        });
+    });
+});
+//# sourceMappingURL=hierarchyService.issue38.test.js.map

package/lib/tests/processService.comprehensive.test.js

@@ -222,7 +222,7 @@ describe('ProcessService - Comprehensive Tests', () => {
             mockRestService.post.mockResolvedValue(mockResponse(returnData));
             const result = await processService.executeWithReturn('TestProcess', {}, 30);
             expect(result).toEqual(mockResponse(returnData));
-            expect(mockRestService.post).toHaveBeenCalledWith("/Processes('TestProcess')/tm1.ExecuteWithReturn?$expand=*", "{}", { timeout: 30000 });
+            expect(mockRestService.post).toHaveBeenCalledWith("/Processes('TestProcess')/tm1.ExecuteWithReturn?$expand=*", "{}", { timeout: 30 });
         });
         test('should execute process with return data extraction', async () => {
             const returnData = {
@@ -396,20 +396,20 @@ describe('ProcessService - Comprehensive Tests', () => {
                 ]
             };
             mockRestService.get.mockResolvedValue(mockResponse(breakpointsData));
-            const result = await processService.getProcessDebugBreakpoints('debug-123');
+            const result = await processService.debugGetBreakpoints('debug-123');
             expect(result).toHaveLength(2);
             expect(ProcessDebugBreakpoint_1.ProcessDebugBreakpoint.fromDict).toHaveBeenCalledTimes(2);
             expect(mockRestService.get).toHaveBeenCalledWith("/ProcessDebugContexts('debug-123')/Breakpoints");
         });
-        test('should create process debug breakpoint', async () => {
+        test('should add process debug breakpoint (delegates to debugAddBreakpoints)', async () => {
             mockRestService.post.mockResolvedValue(mockResponse({}));
-            const result = await processService.createProcessDebugBreakpoint('debug-123', mockProcessDebugBreakpoint);
+            const result = await processService.debugAddBreakpoint('debug-123', mockProcessDebugBreakpoint);
             expect(result).toBeDefined();
-            expect(mockRestService.post).toHaveBeenCalledWith("/ProcessDebugContexts('debug-123')/Breakpoints", mockProcessDebugBreakpoint.body);
+            expect(mockRestService.post).toHaveBeenCalledWith("/ProcessDebugContexts('debug-123')/Breakpoints", JSON.stringify([mockProcessDebugBreakpoint.bodyAsDict]));
         });
         test('should delete process debug breakpoint', async () => {
             mockRestService.delete.mockResolvedValue(mockResponse({}));
-            const result = await processService.deleteProcessDebugBreakpoint('debug-123', 5);
+            const result = await processService.debugRemoveBreakpoint('debug-123', 5);
             expect(result).toBeDefined();
             expect(mockRestService.delete).toHaveBeenCalledWith("/ProcessDebugContexts('debug-123')/Breakpoints('5')");
         });
@@ -654,7 +654,7 @@ describe('ProcessService - Comprehensive Tests', () => {
             const debugResponse = { ID: 'ctx-003', Breakpoints: [], CallStack: [] };
             mockRestService.post.mockResolvedValue(mockResponse(debugResponse));
             await processService.debugProcess('TestProcess', 60);
-            expect(mockRestService.post).toHaveBeenCalledWith(expect.any(String), expect.any(String), { timeout: 60000 });
+            expect(mockRestService.post).toHaveBeenCalledWith(expect.any(String), expect.any(String), { timeout: 60 });
         });
         test('debugAddBreakpoints should POST breakpoints array to Breakpoints endpoint', async () => {
             mockRestService.post.mockResolvedValue(mockResponse({}));
@@ -848,10 +848,10 @@ describe('ProcessService - Comprehensive Tests', () => {
             mockRestService.get.mockResolvedValue(mockResponse(debugData));
             mockRestService.delete.mockResolvedValue(mockResponse({}));
             // Debug workflow: set breakpoint, run debug commands, remove breakpoint
-            await processService.createProcessDebugBreakpoint('debug-123', mockProcessDebugBreakpoint);
+            await processService.debugAddBreakpoint('debug-123', mockProcessDebugBreakpoint);
             await processService.debugStepOver('debug-123');
             await processService.debugContinue('debug-123');
-            await processService.deleteProcessDebugBreakpoint('debug-123', 5);
+            await processService.debugRemoveBreakpoint('debug-123', 5);
             expect(mockRestService.post).toHaveBeenCalledTimes(3);
             expect(mockRestService.delete).toHaveBeenCalledTimes(1);
         });