tm1npm 1.5.3 → 1.6.0

package/lib/services/ElementService.js

@@ -1,10 +1,22 @@
 "use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ElementService = exports.MDXDrillMethod = void 0;
 const ObjectService_1 = require("./ObjectService");
 const Element_1 = require("../objects/Element");
 const ElementAttribute_1 = require("../objects/ElementAttribute");
 const Process_1 = require("../objects/Process");
+const ProcessService_1 = require("./ProcessService");
+const HierarchyService_1 = require("./HierarchyService");
+const CellService_1 = require("./CellService");
 const Utils_1 = require("../utils/Utils");
 var MDXDrillMethod;
 (function (MDXDrillMethod) {
@@ -225,6 +237,14 @@ class ElementService extends ObjectService_1.ObjectService {
         const body = elements.map(e => e.bodyAsDict);
         return await this.rest.post(url, JSON.stringify(body));
     }
+    /**
+     * Add multiple element attributes in bulk
+     */
+    async addElementAttributes(dimensionName, hierarchyName, elementAttributes) {
+        const url = (0, Utils_1.formatUrl)("/Dimensions('{}')/Hierarchies('{}')/ElementAttributes", dimensionName, hierarchyName);
+        const body = elementAttributes.map(ea => ea.bodyAsDict);
+        return await this.rest.post(url, JSON.stringify(body));
+    }
     /**
      * Delete multiple elements in bulk
      */
@@ -716,6 +736,200 @@ class ElementService extends ObjectService_1.ObjectService {
         }
         return elements.map(name => `[${dimensionName}].[${hierarchy}].[${name}]`);
     }
+    async getNumberOfConsolidatedElements(dimensionName, hierarchyName) {
+        return this._getElementCountWithFilter(dimensionName, hierarchyName, `Type eq ${Element_1.ElementType.CONSOLIDATED}`);
+    }
+    async getNumberOfLeafElements(dimensionName, hierarchyName) {
+        return this._getElementCountWithFilter(dimensionName, hierarchyName, `Type ne ${Element_1.ElementType.CONSOLIDATED}`);
+    }
+    async getNumberOfNumericElements(dimensionName, hierarchyName) {
+        return this._getElementCountWithFilter(dimensionName, hierarchyName, `Type eq ${Element_1.ElementType.NUMERIC}`);
+    }
+    async getNumberOfStringElements(dimensionName, hierarchyName) {
+        return this._getElementCountWithFilter(dimensionName, hierarchyName, `Type eq ${Element_1.ElementType.STRING}`);
+    }
+    /**
+     * Get element types from all hierarchies in a single API call
+     */
+    async getElementTypesFromAllHierarchies(dimensionName, skipConsolidations = false) {
+        let url = (0, Utils_1.formatUrl)("/Dimensions('{}')?$expand=Hierarchies($select=Elements;$expand=Elements($select=Name,Type", dimensionName);
+        url += skipConsolidations ? ";$filter=Type ne 3))" : "))";
+        const response = await this.rest.get(url);
+        const result = new Utils_1.CaseAndSpaceInsensitiveDict();
+        for (const hierarchy of response.data.Hierarchies) {
+            for (const element of hierarchy.Elements) {
+                result.set(element.Name, element.Type);
+            }
+        }
+        return result;
+    }
+    /**
+     * Check if the element attributes cube exists for a dimension
+     */
+    async attributeCubeExists(dimensionName) {
+        const url = (0, Utils_1.formatUrl)("/Cubes('{}')", Element_1.Element.ELEMENT_ATTRIBUTES_PREFIX + dimensionName);
+        return this._exists(url);
+    }
+    /**
+     * Get parent mapping for all elements in a hierarchy
+     */
+    async getParentsOfAllElements(dimensionName, hierarchyName) {
+        const url = (0, Utils_1.formatUrl)("/Dimensions('{}')/Hierarchies('{}')/Elements?$select=Name&$expand=Parents($select=Name)", dimensionName, hierarchyName);
+        const response = await this.rest.get(url);
+        const result = {};
+        for (const child of response.data.value) {
+            result[child.Name] = (child.Parents || []).map((p) => p.Name);
+        }
+        return result;
+    }
+    /**
+     * Get the canonical/principal name of an element (resolves aliases)
+     */
+    async getElementPrincipalName(dimensionName, hierarchyName, elementName) {
+        const element = await this.get(dimensionName, hierarchyName, elementName);
+        return element.name;
+    }
+    /**
+     * Check if one element is a direct parent of another
+     *
+     * Unlike the related function in TM1 (ELISPAR or ElementIsParent), this function will return false
+     * if an invalid element is passed. An invalid dimension or hierarchy will cause the underlying
+     * REST call to throw (the error propagates from the TM1 server).
+     */
+    async elementIsParent(dimensionName, hierarchyName, parentName, elementName) {
+        const mdx = this._buildDrillIntersectionMdx(dimensionName, hierarchyName, parentName, elementName, 'TM1DrillDownMember', false);
+        const cardinality = await this._getMdxSetCardinality(mdx);
+        return cardinality > 0;
+    }
+    /**
+     * Check if one element is an ancestor of another
+     *
+     * Unlike the related function in TM1 (ELISANC or ElementIsAncestor), this function will return false
+     * if an invalid element is passed; but will raise an exception if an invalid dimension or hierarchy is passed.
+     *
+     * For method you can pass three values:
+     * - 'TI' performs best, but requires admin permissions
+     * - 'TM1DrillDownMember' performs well when element is a leaf
+     * - 'Descendants' performs well when ancestorName and elementName are Consolidations
+     *
+     * If no method is passed, defaults to 'TI' for admin users, 'TM1DrillDownMember' otherwise.
+     * Note: isAdmin is determined from RestService state; if not set, defaults to 'TM1DrillDownMember'.
+     */
+    async elementIsAncestor(dimensionName, hierarchyName, ancestorName, elementName, method) {
+        if (!method) {
+            method = this.isAdmin ? 'TI' : 'TM1DrillDownMember';
+        }
+        if (method.toUpperCase() === 'TI') {
+            if (await this._elementIsAncestorTi(dimensionName, hierarchyName, elementName, ancestorName)) {
+                return true;
+            }
+            if (await this.hierarchyExists(dimensionName, hierarchyName)) {
+                return false;
+            }
+            throw new Error(`Hierarchy: '${hierarchyName}' does not exist in dimension: '${dimensionName}'`);
+        }
+        if (method.toUpperCase() === 'DESCENDANTS' || method.toUpperCase() === 'TM1DRILLDOWNMEMBER') {
+            if (!await this.exists(dimensionName, hierarchyName, elementName)) {
+                if (!await this.hierarchyExists(dimensionName, hierarchyName)) {
+                    throw new Error(`Hierarchy '${hierarchyName}' does not exist in dimension '${dimensionName}'`);
+                }
+                return false;
+            }
+        }
+        const mdx = this._buildDrillIntersectionMdx(dimensionName, hierarchyName, ancestorName, elementName, method, true);
+        const cardinality = await this._getMdxSetCardinality(mdx);
+        return cardinality > 0;
+    }
+    /**
+     * Remove a single edge from a hierarchy
+     */
+    async removeEdge(dimensionName, hierarchyName, parentName, componentName) {
+        const url = (0, Utils_1.formatUrl)("/Dimensions('{}')/Hierarchies('{}')/Elements('{}')/Edges(ParentName='{}',ComponentName='{}')", dimensionName, hierarchyName, parentName, parentName, componentName);
+        return this.rest.delete(url);
+    }
+    /**
+     * Check if a hierarchy exists in a dimension (convenience delegation to HierarchyService)
+     */
+    async hierarchyExists(dimensionName, hierarchyName) {
+        const hierarchyService = new HierarchyService_1.HierarchyService(this.rest);
+        return hierarchyService.exists(dimensionName, hierarchyName);
+    }
+    /**
+     * Get all element names and alias values for leaf elements as a case-and-space-insensitive set
+     */
+    async getAllLeafElementIdentifiers(dimensionName, hierarchyName) {
+        const mdxElements = `{ Tm1FilterByLevel ( { Tm1SubsetAll ([${dimensionName}].[${hierarchyName}]) } , 0 ) }`;
+        const aliasAttributes = await this.getAliasElementAttributes(dimensionName, hierarchyName);
+        if (aliasAttributes.length === 0) {
+            const result = await this.executeSetMdx(mdxElements, undefined, ['Name'], null, null);
+            const identifiers = new Utils_1.CaseAndSpaceInsensitiveSet();
+            for (const record of result) {
+                identifiers.add(record[0].Name);
+            }
+            return identifiers;
+        }
+        const attrMdx = aliasAttributes.map(a => `[}ElementAttributes_${dimensionName}].[}ElementAttributes_${dimensionName}].[${a}]`).join(',');
+        const mdx = `SELECT ${mdxElements} ON ROWS, {${attrMdx}} ON COLUMNS FROM [}ElementAttributes_${dimensionName}]`;
+        return this._retrieveMdxRowsAndCellValuesAsStringSet(mdx);
+    }
+    async _getElementCountWithFilter(dimensionName, hierarchyName, filter) {
+        const baseUrl = (0, Utils_1.formatUrl)("/Dimensions('{}')/Hierarchies('{}')/Elements/$count", dimensionName, hierarchyName);
+        const url = `${baseUrl}?$filter=${filter}`;
+        const response = await this.rest.get(url);
+        return parseInt(response.data) || 0;
+    }
+    _buildDrillIntersectionMdx(dimensionName, hierarchyName, firstElementName, secondElementName, mdxMethod, recursive) {
+        const first = `[${dimensionName}].[${hierarchyName}].[${firstElementName}]`;
+        const second = `[${dimensionName}].[${hierarchyName}].[${secondElementName}]`;
+        let drillSet;
+        if (mdxMethod.toUpperCase() === 'TM1DRILLDOWNMEMBER') {
+            drillSet = recursive
+                ? `{TM1DRILLDOWNMEMBER({${first}}, ALL, RECURSIVE)}`
+                : `{TM1DRILLDOWNMEMBER({${first}}, ALL)}`;
+        }
+        else if (mdxMethod.toUpperCase() === 'DESCENDANTS') {
+            drillSet = `{DESCENDANTS(${first}, ${second}.Level, SELF)}`;
+        }
+        else {
+            throw new Error("Invalid MDX Drill Method. Options: 'TM1DrillDownMember' or 'Descendants'");
+        }
+        return `INTERSECT(${drillSet}, {${second}})`;
+    }
+    async _getMdxSetCardinality(mdx) {
+        const url = '/ExecuteMDXSetExpression?$select=Cardinality';
+        const payload = { MDX: mdx };
+        const response = await this.rest.post(url, JSON.stringify(payload));
+        return response.data.Cardinality || 0;
+    }
+    async _elementIsAncestorTi(dimensionName, hierarchyName, elementName, ancestorName) {
+        const processService = new ProcessService_1.ProcessService(this.rest);
+        const code = `ElementIsAncestor('${(0, Utils_1.escapeODataValue)(dimensionName)}', '${(0, Utils_1.escapeODataValue)(hierarchyName)}', '${(0, Utils_1.escapeODataValue)(ancestorName)}', '${(0, Utils_1.escapeODataValue)(elementName)}')=1`;
+        return processService.evaluateBooleanTiExpression(code);
+    }
+    async _retrieveMdxRowsAndCellValuesAsStringSet(mdx) {
+        const cellService = new CellService_1.CellService(this.rest);
+        const { rows, values } = await cellService.executeMdxRowsAndValues(mdx);
+        const result = new Utils_1.CaseAndSpaceInsensitiveSet();
+        for (const row of rows) {
+            for (const name of row) {
+                if (name) {
+                    result.add(name);
+                }
+            }
+        }
+        for (const value of values) {
+            if (value && typeof value === 'string' && value.trim() !== '') {
+                result.add(value);
+            }
+        }
+        return result;
+    }
 }
 exports.ElementService = ElementService;
+__decorate([
+    Utils_1.requireDataAdmin,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String, String]),
+    __metadata("design:returntype", Promise)
+], ElementService.prototype, "_elementIsAncestorTi", null);
 //# sourceMappingURL=ElementService.js.map

package/lib/services/HierarchyService.d.ts

@@ -2,16 +2,42 @@ import { AxiosResponse } from 'axios';
 import { RestService } from './RestService';
 import { Hierarchy } from '../objects/Hierarchy';
 import { ElementAttribute } from '../objects/ElementAttribute';
+import { Element } from '../objects/Element';
 import { ObjectService } from './ObjectService';
+import { DataFrame } from '../utils/DataFrame';
 export declare class HierarchyService extends ObjectService {
+    private elementService?;
     constructor(rest: RestService);
+    private getElementService;
     create(hierarchy: Hierarchy): Promise<AxiosResponse>;
     get(dimensionName: string, hierarchyName?: string): Promise<Hierarchy>;
     update(hierarchy: Hierarchy, keepExistingAttributes?: boolean): Promise<AxiosResponse[]>;
+    updateOrCreate(hierarchy: Hierarchy): Promise<AxiosResponse | AxiosResponse[]>;
     delete(dimensionName: string, hierarchyName: string): Promise<AxiosResponse>;
     exists(dimensionName: string, hierarchyName: string): Promise<boolean>;
     getAllNames(dimensionName: string): Promise<string[]>;
     getAll(dimensionName: string): Promise<Hierarchy[]>;
+    getHierarchySummary(dimensionName: string, hierarchyName?: string): Promise<Record<string, number>>;
+    getDefaultMember(dimensionName: string, hierarchyName?: string): Promise<string | null>;
+    updateDefaultMember(dimensionName: string, hierarchyName?: string, memberName?: string): Promise<AxiosResponse | void>;
+    private _updateDefaultMemberViaApi;
+    private _updateDefaultMemberViaPropsCube;
+    removeEdgesUnderConsolidation(dimensionName: string, hierarchyName: string, consolidationElement: string): Promise<AxiosResponse[]>;
+    addEdges(dimensionName: string, hierarchyName: string | undefined, edges: {
+        [parent: string]: {
+            [child: string]: number;
+        };
+    }): Promise<AxiosResponse>;
+    addElements(dimensionName: string, hierarchyName: string, elements: Element[]): Promise<AxiosResponse>;
+    addElementAttributes(dimensionName: string, hierarchyName: string, elementAttributes: ElementAttribute[]): Promise<AxiosResponse>;
+    updateOrCreateHierarchyFromDataframe(dimensionName: string, hierarchyName: string, df: DataFrame, options?: {
+        elementColumn?: string;
+        verifyUniqueElements?: boolean;
+        elementTypeColumn?: string;
+        unwindAll?: boolean;
+        unwindConsolidations?: string[];
+        deleteOrphanedConsolidations?: boolean;
+    }): Promise<void>;
     updateElementAttributes(hierarchy: Hierarchy, keepExisting?: boolean): Promise<void>;
     getElementAttributes(dimensionName: string, hierarchyName: string): Promise<ElementAttribute[]>;
     elementAttributeExists(dimensionName: string, hierarchyName: string, attributeName: string): Promise<boolean>;

package/lib/services/HierarchyService.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HierarchyService.d.ts","sourceRoot":"","sources":["../../src/services/HierarchyService.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AACtC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAE/D,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD,qBAAa,gBAAiB,SAAQ,aAAa;gBACnC,IAAI,EAAE,WAAW;IAIhB,MAAM,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,aAAa,CAAC;IASpD,GAAG,CAAC,aAAa,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC;IAWtE,MAAM,CAAC,SAAS,EAAE,SAAS,EAAE,sBAAsB,GAAE,OAAe,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC;IAY/F,MAAM,CAAC,aAAa,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAK5E,MAAM,CAAC,aAAa,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAetE,WAAW,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAMrD,MAAM,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IASnD,uBAAuB,CAAC,SAAS,EAAE,SAAS,EAAE,YAAY,GAAE,OAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAkD3F,oBAAoB,CAAC,aAAa,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAO/F,sBAAsB,CAAC,aAAa,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAc7G,sBAAsB,CAAC,aAAa,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAMnH,cAAc,CAAC,aAAa,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAOrF,UAAU,CAAC,aAAa,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;CAa1F"}
+{"version":3,"file":"HierarchyService.d.ts","sourceRoot":"","sources":["../../src/services/HierarchyService.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AACtC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,EAAE,OAAO,EAAe,MAAM,oBAAoB,CAAC;AAG1D,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAIhD,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAS/C,qBAAa,gBAAiB,SAAQ,aAAa;IAC/C,OAAO,CAAC,cAAc,CAAC,CAAiB;gBAE5B,IAAI,EAAE,WAAW;IAI7B,OAAO,CAAC,iBAAiB;IAOZ,MAAM,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,aAAa,CAAC;IASpD,GAAG,CAAC,aAAa,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC;IAWtE,MAAM,CAAC,SAAS,EAAE,SAAS,EAAE,sBAAsB,GAAE,OAAe,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC;IAY/F,cAAc,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,aAAa,GAAG,aAAa,EAAE,CAAC;IAO9E,MAAM,CAAC,aAAa,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAK5E,MAAM,CAAC,aAAa,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAetE,WAAW,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAMrD,MAAM,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IASnD,mBAAmB,CAC5B,aAAa,EAAE,MAAM,EACrB,aAAa,CAAC,EAAE,MAAM,GACvB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAkBrB,gBAAgB,CACzB,aAAa,EAAE,MAAM,EACrB,aAAa,CAAC,EAAE,MAAM,GACvB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAgBZ,mBAAmB,CAC5B,aAAa,EAAE,MAAM,EACrB,aAAa,CAAC,EAAE,MAAM,EACtB,UAAU,GAAE,MAAW,GACxB,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;YASlB,0BAA0B;YAmB1B,gCAAgC;IAcjC,6BAA6B,CACtC,aAAa,EAAE,MAAM,EACrB,aAAa,EAAE,MAAM,EACrB,oBAAoB,EAAE,MAAM,GAC7B,OAAO,CAAC,aAAa,EAAE,CAAC;IAuBd,QAAQ,CACjB,aAAa,EAAE,MAAM,EACrB,aAAa,EAAE,MAAM,GAAG,SAAS,EACjC,KAAK,EAAE;QAAE,CAAC,MAAM,EAAE,MAAM,GAAG;YAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;SAAE,CAAA;KAAE,GACzD,OAAO,CAAC,aAAa,CAAC;IAIZ,WAAW,CACpB,aAAa,EAAE,MAAM,EACrB,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,OAAO,EAAE,GACpB,OAAO,CAAC,aAAa,CAAC;IAIZ,oBAAoB,CAC7B,aAAa,EAAE,MAAM,EACrB,aAAa,EAAE,MAAM,EACrB,iBAAiB,EAAE,gBAAgB,EAAE,GACtC,OAAO,CAAC,aAAa,CAAC;IAIZ,oCAAoC,CAC7C,aAAa,EAAE,MAAM,EACrB,aAAa,EAAE,MAAM,EACrB,EAAE,EAAE,SAAS,EACb,OAAO,GAAE;QACL,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,oBAAoB,CAAC,EAAE,OAAO,CAAC;QAC/B,iBAAiB,CAAC,EAAE,MAAM,CAAC;QAC3B,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,oBAAoB,CAAC,EAAE,MAAM,EAAE,CAAC;QAChC,4BAA4B,CAAC,EAAE,OAAO,CAAC;KACrC,GACP,OAAO,CAAC,IAAI,CAAC;IAiPH,uBAAuB,CAAC,SAAS,EAAE,SAAS,EAAE,YAAY,GAAE,OAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAkD3F,oBAAoB,CAAC,aAAa,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAO/F,sBAAsB,CAAC,aAAa,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAc7G,sBAAsB,CAAC,aAAa,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAMnH,cAAc,CAAC,aAAa,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAOrF,UAAU,CAAC,aAAa,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;CAa1F"}

package/lib/services/HierarchyService.js

@@ -3,13 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.HierarchyService = void 0;
 const Hierarchy_1 = require("../objects/Hierarchy");
 const ElementAttribute_1 = require("../objects/ElementAttribute");
+const Element_1 = require("../objects/Element");
+const Dimension_1 = require("../objects/Dimension");
 const TM1Exception_1 = require("../exceptions/TM1Exception");
 const ObjectService_1 = require("./ObjectService");
+const ElementService_1 = require("./ElementService");
+const CellService_1 = require("./CellService");
+const DimensionService_1 = require("./DimensionService");
 const Utils_1 = require("../utils/Utils");
 class HierarchyService extends ObjectService_1.ObjectService {
     constructor(rest) {
         super(rest);
     }
+    getElementService() {
+        if (!this.elementService) {
+            this.elementService = new ElementService_1.ElementService(this.rest);
+        }
+        return this.elementService;
+    }
     async create(hierarchy) {
         const url = this.formatUrl("/Dimensions('{}')/Hierarchies", hierarchy.dimensionName);
         const response = await this.rest.post(url, hierarchy.body);
@@ -30,6 +41,12 @@ class HierarchyService extends ObjectService_1.ObjectService {
         await this.updateElementAttributes(hierarchy, keepExistingAttributes);
         return responses;
     }
+    async updateOrCreate(hierarchy) {
+        if (await this.exists(hierarchy.dimensionName, hierarchy.name)) {
+            return await this.update(hierarchy);
+        }
+        return await this.create(hierarchy);
+    }
     async delete(dimensionName, hierarchyName) {
         const url = this.formatUrl("/Dimensions('{}')/Hierarchies('{}')", dimensionName, hierarchyName);
         return await this.rest.delete(url);
@@ -58,6 +75,295 @@ class HierarchyService extends ObjectService_1.ObjectService {
         const response = await this.rest.get(url);
         return response.data.value.map((h) => Hierarchy_1.Hierarchy.fromDict(h, dimensionName));
     }
+    async getHierarchySummary(dimensionName, hierarchyName) {
+        var _a, _b, _c, _d, _e;
+        const hierarchy = hierarchyName || dimensionName;
+        const url = this.formatUrl("/Dimensions('{}')/Hierarchies('{}')" +
+            "?$expand=Edges/$count,Elements/$count,ElementAttributes/$count,Members/$count,Levels/$count" +
+            "&$select=Cardinality", dimensionName, hierarchy);
+        const response = await this.rest.get(url);
+        const data = response.data;
+        return {
+            Elements: (_a = data['Elements@odata.count']) !== null && _a !== void 0 ? _a : 0,
+            Edges: (_b = data['Edges@odata.count']) !== null && _b !== void 0 ? _b : 0,
+            ElementAttributes: (_c = data['ElementAttributes@odata.count']) !== null && _c !== void 0 ? _c : 0,
+            Members: (_d = data['Members@odata.count']) !== null && _d !== void 0 ? _d : 0,
+            Levels: (_e = data['Levels@odata.count']) !== null && _e !== void 0 ? _e : 0
+        };
+    }
+    async getDefaultMember(dimensionName, hierarchyName) {
+        var _a;
+        const hierarchy = hierarchyName || dimensionName;
+        const url = this.formatUrl("/Dimensions('{}')/Hierarchies('{}')/DefaultMember", dimensionName, hierarchy);
+        try {
+            const response = await this.rest.get(url);
+            return ((_a = response.data) === null || _a === void 0 ? void 0 : _a.Name) || null;
+        }
+        catch (error) {
+            if (error instanceof TM1Exception_1.TM1RestException && error.statusCode === 404) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async updateDefaultMember(dimensionName, hierarchyName, memberName = '') {
+        const hierarchy = hierarchyName || dimensionName;
+        // Default to API approach (v12+) when version is unknown
+        if (!this.version || (0, Utils_1.verifyVersion)(this.version, '12.0.0')) {
+            return this._updateDefaultMemberViaApi(dimensionName, hierarchy, memberName);
+        }
+        return this._updateDefaultMemberViaPropsCube(dimensionName, hierarchy, memberName);
+    }
+    async _updateDefaultMemberViaApi(dimensionName, hierarchyName, memberName) {
+        const url = this.formatUrl("/Dimensions('{}')/Hierarchies('{}')", dimensionName, hierarchyName);
+        const body = {};
+        if (memberName) {
+            body['DefaultMember@odata.bind'] = (0, Utils_1.formatUrl)("Dimensions('{}')/Hierarchies('{}')/Elements('{}')", dimensionName, hierarchyName, memberName);
+        }
+        else {
+            body['DefaultMember@odata.bind'] = null;
+        }
+        return await this.rest.patch(url, JSON.stringify(body));
+    }
+    async _updateDefaultMemberViaPropsCube(dimensionName, hierarchyName, memberName) {
+        const cellService = new CellService_1.CellService(this.rest);
+        const value = memberName || '';
+        await cellService.writeValue('}HierarchyProperties', [dimensionName, hierarchyName, 'MEMBER_DEFAULT'], value);
+    }
+    async removeEdgesUnderConsolidation(dimensionName, hierarchyName, consolidationElement) {
+        const hierarchy = await this.get(dimensionName, hierarchyName);
+        const descendants = hierarchy.getDescendants(consolidationElement, true);
+        const membersUnderConsolidation = new Utils_1.CaseAndSpaceInsensitiveSet(descendants);
+        membersUnderConsolidation.add(consolidationElement);
+        const edgesToRemove = [];
+        for (const [parent, children] of hierarchy.edges) {
+            if (membersUnderConsolidation.has(parent)) {
+                for (const child of children.keys()) {
+                    edgesToRemove.push([parent, child]);
+                }
+            }
+        }
+        for (const [parent, child] of edgesToRemove) {
+            hierarchy.removeEdge(parent, child);
+        }
+        return await this.update(hierarchy);
+    }
+    async addEdges(dimensionName, hierarchyName, edges) {
+        return this.getElementService().addEdges(dimensionName, hierarchyName || dimensionName, edges);
+    }
+    async addElements(dimensionName, hierarchyName, elements) {
+        return this.getElementService().addElements(dimensionName, hierarchyName, elements);
+    }
+    async addElementAttributes(dimensionName, hierarchyName, elementAttributes) {
+        return this.getElementService().addElementAttributes(dimensionName, hierarchyName, elementAttributes);
+    }
+    async updateOrCreateHierarchyFromDataframe(dimensionName, hierarchyName, df, options = {}) {
+        const { elementColumn: elemCol, verifyUniqueElements = false, elementTypeColumn = 'ElementType', unwindAll = false, unwindConsolidations, deleteOrphanedConsolidations = false } = options;
+        const elementColumn = elemCol || df.columns[0];
+        const rows = df.toJson();
+        const numericSuffix = (col) => parseInt(col.replace(/\D/g, ''), 10);
+        const levelColumns = df.columns
+            .filter(c => /^Level\d+$/i.test(c))
+            .sort((a, b) => numericSuffix(a) - numericSuffix(b));
+        const weightColumns = df.columns
+            .filter(c => /^Weight\d+$/i.test(c))
+            .sort((a, b) => numericSuffix(a) - numericSuffix(b));
+        const reservedColumns = new Set([
+            elementColumn.toLowerCase(),
+            elementTypeColumn.toLowerCase(),
+            ...levelColumns.map(c => c.toLowerCase()),
+            ...weightColumns.map(c => c.toLowerCase())
+        ]);
+        const attributeColumns = df.columns.filter(c => !reservedColumns.has(c.toLowerCase()));
+        if (verifyUniqueElements) {
+            const seen = new Utils_1.CaseAndSpaceInsensitiveSet();
+            for (const row of rows) {
+                const name = String(row[elementColumn]);
+                if (seen.has(name)) {
+                    throw new Error(`Duplicate element found: '${name}'`);
+                }
+                seen.add(name);
+            }
+        }
+        // Parse DataFrame rows into elements, edges, and attribute values
+        const elementsToAdd = [];
+        const edgesToAdd = {};
+        const attributeValues = new Map();
+        for (const row of rows) {
+            const elementName = String(row[elementColumn]);
+            const elementTypeStr = df.columns.includes(elementTypeColumn)
+                ? String(row[elementTypeColumn] || 'Numeric')
+                : 'Numeric';
+            // Element constructor handles string→ElementType conversion
+            elementsToAdd.push(new Element_1.Element(elementName, elementTypeStr));
+            for (let i = 0; i < levelColumns.length; i++) {
+                const parentName = row[levelColumns[i]];
+                if (parentName && String(parentName).trim()) {
+                    const weight = weightColumns[i] ? Number(row[weightColumns[i]] || 1) : 1;
+                    const parentStr = String(parentName);
+                    if (!edgesToAdd[parentStr]) {
+                        edgesToAdd[parentStr] = {};
+                    }
+                    edgesToAdd[parentStr][elementName] = weight;
+                }
+            }
+            if (attributeColumns.length > 0) {
+                const attrs = new Map();
+                for (const col of attributeColumns) {
+                    if (row[col] !== undefined && row[col] !== null && row[col] !== '') {
+                        attrs.set(col, row[col]);
+                    }
+                }
+                if (attrs.size > 0) {
+                    attributeValues.set(elementName, attrs);
+                }
+            }
+        }
+        // Get or create the dimension/hierarchy
+        const dimensionService = new DimensionService_1.DimensionService(this.rest);
+        const hierarchyExists = await this.exists(dimensionName, hierarchyName).catch(() => false);
+        let hierarchy;
+        if (hierarchyExists) {
+            hierarchy = await this.get(dimensionName, hierarchyName);
+        }
+        else {
+            const newHierarchy = new Hierarchy_1.Hierarchy(hierarchyName, dimensionName);
+            try {
+                const dim = new Dimension_1.Dimension(dimensionName, [newHierarchy]);
+                await dimensionService.create(dim);
+            }
+            catch (e) {
+                const isAlreadyExists = (e instanceof TM1Exception_1.TM1RestException && e.statusCode === 409)
+                    || (e.message && e.message.includes('already exists'));
+                if (isAlreadyExists) {
+                    // Dimension exists but hierarchy doesn't — create just the hierarchy
+                    await this.create(newHierarchy);
+                }
+                else {
+                    throw e;
+                }
+            }
+            hierarchy = await this.get(dimensionName, hierarchyName);
+        }
+        // Unwind edges if requested
+        if (unwindAll) {
+            await this.removeAllEdges(dimensionName, hierarchyName);
+        }
+        else if (unwindConsolidations && unwindConsolidations.length > 0) {
+            for (const consolidation of unwindConsolidations) {
+                try {
+                    await this.removeEdgesUnderConsolidation(dimensionName, hierarchyName, consolidation);
+                }
+                catch (e) {
+                    if (!(e instanceof TM1Exception_1.TM1RestException && e.statusCode === 404)) {
+                        throw e;
+                    }
+                }
+            }
+        }
+        // Re-fetch hierarchy only if edges were modified
+        if (unwindAll || (unwindConsolidations && unwindConsolidations.length > 0)) {
+            hierarchy = await this.get(dimensionName, hierarchyName);
+        }
+        // Add new elements not already in hierarchy
+        const existingElementNames = new Utils_1.CaseAndSpaceInsensitiveSet(hierarchy.elements.map(e => e.name));
+        const newElements = elementsToAdd.filter(e => !existingElementNames.has(e.name));
+        // Ensure parent elements from edges exist as Consolidated type
+        const newElementNames = new Utils_1.CaseAndSpaceInsensitiveSet(newElements.map(e => e.name));
+        const parentElementsToAdd = [];
+        for (const parentName of Object.keys(edgesToAdd)) {
+            if (!existingElementNames.has(parentName) && !newElementNames.has(parentName)) {
+                parentElementsToAdd.push(new Element_1.Element(parentName, Element_1.ElementType.CONSOLIDATED));
+            }
+        }
+        const allNewElements = [...newElements, ...parentElementsToAdd];
+        if (allNewElements.length > 0) {
+            await this.addElements(dimensionName, hierarchyName, allNewElements);
+        }
+        // Create missing element attributes and write values
+        if (attributeColumns.length > 0) {
+            const existingAttrs = await this.getElementAttributes(dimensionName, hierarchyName);
+            const existingAttrNames = new Utils_1.CaseAndSpaceInsensitiveSet(existingAttrs.map(a => a.name));
+            const newAttrs = [];
+            for (const col of attributeColumns) {
+                if (!existingAttrNames.has(col)) {
+                    const values = rows.map(r => r[col]).filter(v => v !== undefined && v !== null && v !== '');
+                    const isNumeric = values.length > 0 && values.every(v => !isNaN(Number(v)));
+                    newAttrs.push(new ElementAttribute_1.ElementAttribute(col, isNumeric ? 'Numeric' : 'String'));
+                }
+            }
+            if (newAttrs.length > 0) {
+                await this.addElementAttributes(dimensionName, hierarchyName, newAttrs);
+            }
+            // Write attribute values in parallel batches
+            if (attributeValues.size > 0) {
+                const cellService = new CellService_1.CellService(this.rest);
+                const cubeName = `}ElementAttributes_${dimensionName}`;
+                const writePromises = [];
+                for (const [elementName, attrs] of attributeValues) {
+                    for (const [attrName, value] of attrs) {
+                        writePromises.push(cellService.writeValue(cubeName, [elementName, attrName], value)
+                            .catch((e) => {
+                            // Expected: element may not exist in control dimension
+                            if (!(e instanceof TM1Exception_1.TM1RestException && e.statusCode === 404)) {
+                                throw e;
+                            }
+                        }));
+                    }
+                }
+                await Promise.all(writePromises);
+            }
+        }
+        // Add edges
+        if (Object.keys(edgesToAdd).length > 0) {
+            try {
+                await this.addEdges(dimensionName, hierarchyName, edgesToAdd);
+            }
+            catch (bulkError) {
+                // Only fall back on client errors (400, 422); re-throw server/network errors
+                if (!(bulkError instanceof TM1Exception_1.TM1RestException) ||
+                    (bulkError.statusCode !== 400 && bulkError.statusCode !== 422)) {
+                    throw bulkError;
+                }
+                // Bulk failed due to validation; fall back to individual edge adds
+                const edgePromises = [];
+                for (const [parent, children] of Object.entries(edgesToAdd)) {
+                    for (const [child, weight] of Object.entries(children)) {
+                        edgePromises.push(this.addEdges(dimensionName, hierarchyName, { [parent]: { [child]: weight } })
+                            .catch((e) => {
+                            if (e instanceof TM1Exception_1.TM1RestException && e.statusCode === 409) {
+                                return null;
+                            }
+                            throw e;
+                        }));
+                    }
+                }
+                await Promise.all(edgePromises);
+            }
+        }
+        // Delete orphaned consolidations (consolidated elements with no children)
+        if (deleteOrphanedConsolidations) {
+            const updatedHierarchy = await this.get(dimensionName, hierarchyName);
+            const parentNames = new Utils_1.CaseAndSpaceInsensitiveSet();
+            for (const [parent] of updatedHierarchy.edges) {
+                parentNames.add(parent);
+            }
+            const elemService = this.getElementService();
+            const deletePromises = [];
+            for (const element of updatedHierarchy.elements) {
+                if (element.elementType === Element_1.ElementType.CONSOLIDATED && !parentNames.has(element.name)) {
+                    deletePromises.push(elemService.delete(dimensionName, hierarchyName, element.name)
+                        .catch((e) => {
+                        // Expected: element may have been deleted already (404)
+                        if (!(e instanceof TM1Exception_1.TM1RestException && e.statusCode === 404)) {
+                            throw e;
+                        }
+                    }));
+                }
+            }
+            await Promise.all(deletePromises);
+        }
+    }
     async updateElementAttributes(hierarchy, keepExisting = false) {
         const existingAttributes = await this.getElementAttributes(hierarchy.dimensionName, hierarchy.name);
         const existingByName = new Utils_1.CaseAndSpaceInsensitiveDict();