tm1npm 2.0.0 → 2.1.0

package/src/objects/NativeView.ts

@@ -163,86 +163,70 @@ export class NativeView extends View {
         this._rows.push(row);
     }
 
-    public removeTitle(dimensionName: string): boolean {
-        const index = this._titles.findIndex(t =>
-            caseAndSpaceInsensitiveEquals(t.dimensionName, dimensionName));
-        if (index !== -1) {
-            this._titles.splice(index, 1);
-            return true;
-        }
-        return false;
+    public removeTitle(dimensionName: string): void {
+        this._titles = this._titles.filter(
+            t => !caseAndSpaceInsensitiveEquals(t.dimensionName, dimensionName));
     }
 
-    public removeColumn(dimensionName: string): boolean {
-        const index = this._columns.findIndex(c =>
-            caseAndSpaceInsensitiveEquals(c.subset.dimensionName, dimensionName));
-        if (index !== -1) {
-            this._columns.splice(index, 1);
-            return true;
-        }
-        return false;
+    public removeColumn(dimensionName: string): void {
+        this._columns = this._columns.filter(
+            c => !caseAndSpaceInsensitiveEquals(c.dimensionName, dimensionName));
     }
 
-    public removeRow(dimensionName: string): boolean {
-        const index = this._rows.findIndex(r =>
-            caseAndSpaceInsensitiveEquals(r.subset.dimensionName, dimensionName));
-        if (index !== -1) {
-            this._rows.splice(index, 1);
-            return true;
-        }
-        return false;
+    public removeRow(dimensionName: string): void {
+        this._rows = this._rows.filter(
+            r => !caseAndSpaceInsensitiveEquals(r.dimensionName, dimensionName));
     }
 
     public substituteTitle(dimension: string, element: string): void {
-        /** Substitute the title element for a given dimension
-         *
-         * :param dimension: str, name of dimension
-         * :param element: str, name of element
-         */
         for (const title of this._titles) {
             if (caseAndSpaceInsensitiveEquals(title.dimensionName, dimension)) {
+                title.subset = new AnonymousSubset(dimension, dimension, undefined, [element]);
                 title.selected = element;
                 return;
             }
         }
-        throw new Error(`No title with dimension: '${dimension}'`);
+        throw new Error(`Dimension '${dimension}' not found in titles`);
     }
 
-    public static fromJSON(viewAsJson: string, cubeName: string): NativeView {
+    public static fromJSON(viewAsJson: string, cubeName?: string): NativeView {
         const viewAsDict = JSON.parse(viewAsJson);
         return NativeView.fromDict(viewAsDict, cubeName);
     }
 
-    public static fromDict(viewAsDict: any, cubeName: string): NativeView {
+    public static fromDict(viewAsDict: any, cubeName?: string): NativeView {
+        let resolvedCube = cubeName;
+        if (!resolvedCube) {
+            const ctx: string = viewAsDict["@odata.context"];
+            resolvedCube = ctx.substring(20, ctx.indexOf("')/"));
+        }
+
         const view = new NativeView(
-            cubeName,
+            resolvedCube,
             viewAsDict.Name,
             viewAsDict.SuppressEmptyColumns || false,
             viewAsDict.SuppressEmptyRows || false,
             viewAsDict.FormatString || "0.#########"
         );
 
-        // Parse titles
         if (viewAsDict.Titles) {
             for (const titleDict of viewAsDict.Titles) {
-                const title = ViewTitleSelection.fromDict(titleDict);
-                view.addTitle(title);
+                if (!('Selected' in titleDict) && !('Selected@odata.bind' in titleDict)) {
+                    throw new Error("View Title dict must contain 'Selected' or 'Selected@odata.bind' as key");
+                }
+                view.addTitle(ViewTitleSelection.fromDict(titleDict));
             }
         }
 
-        // Parse columns
         if (viewAsDict.Columns) {
             for (const columnDict of viewAsDict.Columns) {
-                const column = ViewAxisSelection.fromDict(columnDict);
-                view.addColumn(column);
+                view.addColumn(ViewAxisSelection.fromDict(columnDict));
             }
         }
 
-        // Parse rows
         if (viewAsDict.Rows) {
             for (const rowDict of viewAsDict.Rows) {
-                const row = ViewAxisSelection.fromDict(rowDict);
-                view.addRow(row);
+                view.addRow(ViewAxisSelection.fromDict(rowDict));
             }
         }
 

package/src/objects/Process.ts

@@ -15,7 +15,7 @@ export class Process extends TM1Object {
     public static readonly MAX_STATEMENTS_POST_11_8_015 = 100_000;
 
     private _name: string;
-    private _hasSecurityAccess: boolean;
+    private _hasSecurityAccess: boolean | undefined;
     private _uiData: string;
     private _parameters: any[];
     private _variables: any[];
@@ -28,7 +28,7 @@ export class Process extends TM1Object {
     private _datasourceAsciiDecimalSeparator: string;
     private _datasourceAsciiDelimiterChar: string;
     private _datasourceAsciiDelimiterType: string;
-    private _datasourceAsciiHeaderRecords: number;
+    private _datasourceAsciiHeaderRecords: number | string;
     private _datasourceAsciiQuoteCharacter: string;
     private _datasourceAsciiThousandSeparator: string;
     private _datasourceDataSourceNameForClient: string;
@@ -36,7 +36,7 @@ export class Process extends TM1Object {
     private _datasourcePassword: string;
     private _datasourceUserName: string;
     private _datasourceQuery: string;
-    private _datasourceUsesUnicode: boolean;
+    private _datasourceUsesUnicode: boolean | string;
     private _datasourceView: string;
     private _datasourceSubset: string;
     private _datasourceJsonRootPointer: string;
@@ -60,7 +60,7 @@ export class Process extends TM1Object {
 
     constructor(
         name: string,
-        hasSecurityAccess: boolean = false,
+        hasSecurityAccess: boolean | undefined = false,
         uiData: string = "CubeAction=1511\fDataAction=1503\fCubeLogChanges=0\f",
         parameters?: Iterable<any>,
         variables?: Iterable<any>,
@@ -73,7 +73,7 @@ export class Process extends TM1Object {
         datasourceAsciiDecimalSeparator: string = '.',
         datasourceAsciiDelimiterChar: string = ';',
         datasourceAsciiDelimiterType: string = 'Character',
-        datasourceAsciiHeaderRecords: number = 1,
+        datasourceAsciiHeaderRecords: number | string = 1,
         datasourceAsciiQuoteCharacter: string = '',
         datasourceAsciiThousandSeparator: string = ',',
         datasourceDataSourceNameForClient: string = '',
@@ -81,7 +81,7 @@ export class Process extends TM1Object {
         datasourcePassword: string = '',
         datasourceUserName: string = '',
         datasourceQuery: string = '',
-        datasourceUsesUnicode: boolean = true,
+        datasourceUsesUnicode: boolean | string = true,
         datasourceView: string = '',
         datasourceSubset: string = '',
         datasourceJsonRootPointer: string = '',
@@ -123,11 +123,18 @@ export class Process extends TM1Object {
         this._uiData = uiData;
         this._parameters = parameters ? Array.from(parameters) : [];
         this._variables = variables ? Array.from(variables) : [];
-        this._variablesUiData = variablesUiData ? Array.from(variablesUiData) : [];
-        this._prologProcedure = prologProcedure;
-        this._metadataProcedure = metadataProcedure;
-        this._dataProcedure = dataProcedure;
-        this._epilogProcedure = epilogProcedure;
+        if (variablesUiData) {
+            // Handle encoding issue in variable_ui_data for async requests
+            this._variablesUiData = Array.from(variablesUiData).map((entry: any) =>
+                typeof entry === 'string' ? entry.replace(/€/g, '\f') : entry
+            );
+        } else {
+            this._variablesUiData = [];
+        }
+        this._prologProcedure = Process.addGeneratedStringToCode(prologProcedure);
+        this._metadataProcedure = Process.addGeneratedStringToCode(metadataProcedure);
+        this._dataProcedure = Process.addGeneratedStringToCode(dataProcedure);
+        this._epilogProcedure = Process.addGeneratedStringToCode(epilogProcedure);
         this._datasourceType = datasourceType;
         this._datasourceAsciiDecimalSeparator = datasourceAsciiDecimalSeparator;
         this._datasourceAsciiDelimiterChar = datasourceAsciiDelimiterChar;
@@ -155,11 +162,11 @@ export class Process extends TM1Object {
         this._name = value;
     }
 
-    public get hasSecurityAccess(): boolean {
+    public get hasSecurityAccess(): boolean | undefined {
         return this._hasSecurityAccess;
     }
 
-    public set hasSecurityAccess(value: boolean) {
+    public set hasSecurityAccess(value: boolean | undefined) {
         this._hasSecurityAccess = value;
     }
 
@@ -241,37 +248,110 @@ export class Process extends TM1Object {
          * :param process_as_dict: process as dict
          * :return: process, an instance of this class
          */
+        const ds = processAsDict['DataSource'] ?? {};
         return new Process(
-            processAsDict.Name,
-            processAsDict.HasSecurityAccess || false,
-            processAsDict.UIData || "CubeAction=1511\fDataAction=1503\fCubeLogChanges=0\f",
-            processAsDict.Parameters || [],
-            processAsDict.Variables || [],
-            processAsDict.VariablesUIData || [],
-            processAsDict.PrologProcedure || '',
-            processAsDict.MetadataProcedure || '',
-            processAsDict.DataProcedure || '',
-            processAsDict.EpilogProcedure || '',
-            processAsDict.DataSource?.Type || 'None',
-            processAsDict.DataSource?.AsciiDecimalSeparator || '.',
-            processAsDict.DataSource?.AsciiDelimiterChar || ';',
-            processAsDict.DataSource?.AsciiDelimiterType || 'Character',
-            processAsDict.DataSource?.AsciiHeaderRecords || 1,
-            processAsDict.DataSource?.AsciiQuoteCharacter || '',
-            processAsDict.DataSource?.AsciiThousandSeparator || ',',
-            processAsDict.DataSource?.DataSourceNameForClient || '',
-            processAsDict.DataSource?.DataSourceNameForServer || '',
-            processAsDict.DataSource?.Password || '',
-            processAsDict.DataSource?.UserName || '',
-            processAsDict.DataSource?.Query || '',
-            processAsDict.DataSource?.UsesUnicode !== false,
-            processAsDict.DataSource?.View || '',
-            processAsDict.DataSource?.Subset || '',
-            processAsDict.DataSource?.JsonRootPointer || '',
-            processAsDict.DataSource?.JsonVariableMapping || ''
+            processAsDict['Name'],
+            processAsDict['HasSecurityAccess'],
+            processAsDict['UIData'] ?? '',
+            processAsDict['Parameters'],
+            processAsDict['Variables'],
+            processAsDict['VariablesUIData'] ?? '',
+            processAsDict['PrologProcedure'],
+            processAsDict['MetadataProcedure'],
+            processAsDict['DataProcedure'],
+            processAsDict['EpilogProcedure'],
+            ds['Type'] ?? '',
+            ds['asciiDecimalSeparator'] ?? '',
+            ds['asciiDelimiterChar'] ?? '',
+            ds['asciiDelimiterType'] ?? '',
+            ds['asciiHeaderRecords'] ?? '',
+            ds['asciiQuoteCharacter'] ?? '',
+            ds['asciiThousandSeparator'] ?? '',
+            ds['dataSourceNameForClient'] ?? '',
+            ds['dataSourceNameForServer'] ?? '',
+            ds['password'] ?? '',
+            ds['userName'] ?? '',
+            ds['query'] ?? '',
+            ds['usesUnicode'] ?? '',
+            ds['view'] ?? '',
+            ds['subset'] ?? '',
+            ds['jsonRootPointer'] ?? '',
+            ds['jsonVariableMapping'] ?? ''
         );
     }
 
+    public addVariable(name: string, variableType: string): void {
+        // variable consists of actual variable and UI-Information ('ignore','other', etc.)
+        // 1. handle Variable info
+        const variable = {
+            Name: name,
+            Type: variableType,
+            Position: this._variables.length + 1,
+            StartByte: 0,
+            EndByte: 0,
+        };
+        this._variables.push(variable);
+        // 2. handle UI info
+        const varType = variableType === 'Numeric' ? 33 : 32;
+        // '\f' !
+        const variableUiData = 'VarType=' + varType + '\f' + 'ColType=' + 827 + '\f';
+        /*
+         * mapping VariableUIData:
+         *     VarType 33 -> Numeric
+         *     VarType 32 -> String
+         *     ColType 827 -> Other
+         */
+        this._variablesUiData.push(variableUiData);
+    }
+
+    public removeVariable(name: string): void {
+        for (const variable of this._variables.slice()) {
+            if (variable['Name'] === name) {
+                const vuid = this._variablesUiData[this._variables.indexOf(variable)];
+                const vuidIdx = this._variablesUiData.indexOf(vuid);
+                if (vuidIdx !== -1) {
+                    this._variablesUiData.splice(vuidIdx, 1);
+                }
+                const varIdx = this._variables.indexOf(variable);
+                if (varIdx !== -1) {
+                    this._variables.splice(varIdx, 1);
+                }
+            }
+        }
+    }
+
+    public addParameter(
+        name: string,
+        prompt: string,
+        value: string | number,
+        parameterType?: string
+    ): void {
+        if (!parameterType) {
+            parameterType = typeof value === 'string' ? 'String' : 'Numeric';
+        }
+        const parameter = { Name: name, Prompt: prompt, Value: value, Type: parameterType };
+        this._parameters.push(parameter);
+    }
+
+    public removeParameter(name: string): void {
+        for (const parameter of this._parameters.slice()) {
+            if (parameter['Name'] === name) {
+                const idx = this._parameters.indexOf(parameter);
+                if (idx !== -1) {
+                    this._parameters.splice(idx, 1);
+                }
+            }
+        }
+    }
+
+    public dropParameterTypes(): void {
+        for (let p = 0; p < this._parameters.length; p++) {
+            if ('Type' in this._parameters[p]) {
+                delete this._parameters[p]['Type'];
+            }
+        }
+    }
+
     public get body(): string {
         return JSON.stringify(this.constructBody());
     }
@@ -281,40 +361,76 @@ export class Process extends TM1Object {
     }
 
     private constructBody(): any {
-        const body: any = {
+        // general parameters — key order matches tm1py _construct_body_as_dict
+        const bodyAsDict: any = {
             Name: this._name,
+            PrologProcedure: this._prologProcedure,
+            MetadataProcedure: this._metadataProcedure,
+            DataProcedure: this._dataProcedure,
+            EpilogProcedure: this._epilogProcedure,
             HasSecurityAccess: this._hasSecurityAccess,
             UIData: this._uiData,
+            DataSource: {},
             Parameters: this._parameters,
             Variables: this._variables,
             VariablesUIData: this._variablesUiData,
-            PrologProcedure: this._prologProcedure,
-            MetadataProcedure: this._metadataProcedure,
-            DataProcedure: this._dataProcedure,
-            EpilogProcedure: this._epilogProcedure
         };
 
-        // Add DataSource information
-        body.DataSource = {
-            Type: this._datasourceType,
-            AsciiDecimalSeparator: this._datasourceAsciiDecimalSeparator,
-            AsciiDelimiterChar: this._datasourceAsciiDelimiterChar,
-            AsciiDelimiterType: this._datasourceAsciiDelimiterType,
-            AsciiHeaderRecords: this._datasourceAsciiHeaderRecords,
-            AsciiQuoteCharacter: this._datasourceAsciiQuoteCharacter,
-            AsciiThousandSeparator: this._datasourceAsciiThousandSeparator,
-            DataSourceNameForClient: this._datasourceDataSourceNameForClient,
-            DataSourceNameForServer: this._datasourceDataSourceNameForServer,
-            Password: this._datasourcePassword,
-            UserName: this._datasourceUserName,
-            Query: this._datasourceQuery,
-            UsesUnicode: this._datasourceUsesUnicode,
-            View: this._datasourceView,
-            Subset: this._datasourceSubset,
-            JsonRootPointer: this._datasourceJsonRootPointer,
-            JsonVariableMapping: this._datasourceJsonVariableMapping
-        };
+        // specific parameters (depending on datasource type)
+        if (this._datasourceType === 'ASCII') {
+            bodyAsDict['DataSource'] = {
+                Type: this._datasourceType,
+                asciiDecimalSeparator: this._datasourceAsciiDecimalSeparator,
+                asciiDelimiterChar: this._datasourceAsciiDelimiterChar,
+                asciiDelimiterType: this._datasourceAsciiDelimiterType,
+                asciiHeaderRecords: this._datasourceAsciiHeaderRecords,
+                asciiQuoteCharacter: this._datasourceAsciiQuoteCharacter,
+                asciiThousandSeparator: this._datasourceAsciiThousandSeparator,
+                dataSourceNameForClient: this._datasourceDataSourceNameForClient,
+                dataSourceNameForServer: this._datasourceDataSourceNameForServer,
+            };
+            if (this._datasourceAsciiDelimiterType === 'FixedWidth') {
+                delete bodyAsDict['DataSource']['asciiDelimiterChar'];
+            }
+        } else if (this._datasourceType === 'None') {
+            bodyAsDict['DataSource'] = { Type: 'None' };
+        } else if (this._datasourceType === 'ODBC') {
+            bodyAsDict['DataSource'] = {
+                Type: this._datasourceType,
+                dataSourceNameForClient: this._datasourceDataSourceNameForClient,
+                dataSourceNameForServer: this._datasourceDataSourceNameForServer,
+                userName: this._datasourceUserName,
+                password: this._datasourcePassword,
+                query: this._datasourceQuery,
+                usesUnicode: this._datasourceUsesUnicode,
+            };
+        } else if (this._datasourceType === 'TM1CubeView') {
+            bodyAsDict['DataSource'] = {
+                Type: this._datasourceType,
+                // Note: tm1py uses _datasource_data_source_name_for_server for BOTH client and server
+                dataSourceNameForClient: this._datasourceDataSourceNameForServer,
+                dataSourceNameForServer: this._datasourceDataSourceNameForServer,
+                view: this._datasourceView,
+            };
+        } else if (this._datasourceType === 'TM1DimensionSubset') {
+            bodyAsDict['DataSource'] = {
+                Type: this._datasourceType,
+                // Note: tm1py uses _datasource_data_source_name_for_server for BOTH client and server
+                dataSourceNameForClient: this._datasourceDataSourceNameForServer,
+                dataSourceNameForServer: this._datasourceDataSourceNameForServer,
+                subset: this._datasourceSubset,
+            };
+        } else if (this._datasourceType === 'JSON') {
+            bodyAsDict['DataSource'] = {
+                Type: this._datasourceType,
+                // Note: tm1py uses _datasource_data_source_name_for_server for BOTH client and server
+                dataSourceNameForClient: this._datasourceDataSourceNameForServer,
+                dataSourceNameForServer: this._datasourceDataSourceNameForServer,
+                jsonRootPointer: this._datasourceJsonRootPointer,
+                jsonVariableMapping: this._datasourceJsonVariableMapping,
+            };
+        }
 
-        return body;
+        return bodyAsDict;
     }
 }

package/src/objects/Subset.ts

@@ -240,14 +240,28 @@ export class AnonymousSubset extends Subset {
         } else if ("Hierarchy@odata.bind" in subsetAsDict) {
             const hierarchyOdata = subsetAsDict["Hierarchy@odata.bind"];
 
-            dimensionName = readObjectNameFromUrl(hierarchyOdata);
-            hierarchyName = readObjectNameFromUrl(hierarchyOdata);
+            // tm1py parity (TM1py/Objects/Subset.py): two read_object_name_from_url
+            // calls with these exact regex patterns. Both return match.group(1) (the
+            // first capture group), so both names resolve to the dimension. This
+            // mirrors tm1py's behavior — including the latent bug where a non-default
+            // hierarchy name in the URL is dropped. Do NOT "fix" without tm1py.
+            const dimResult = readObjectNameFromUrl(
+                hierarchyOdata,
+                /^Dimensions\('(.*?)'\)\/Hierarchies\('(.+?)'\)/
+            );
+            const hierResult = readObjectNameFromUrl(
+                hierarchyOdata,
+                /^Dimensions\('(.+?)'\)\/Hierarchies\('(.*?)'\)/
+            );
 
-            if (!dimensionName || !hierarchyName) {
+            if (!dimResult || !hierResult) {
                 throw new Error(
                     `Unexpected value for 'Hierarchy@odata.bind' property in subset dict: '${hierarchyOdata}'`
                 );
             }
+
+            dimensionName = dimResult;
+            hierarchyName = hierResult;
         } else {
             throw new Error("Subset dict must contain 'Hierarchy' or 'Hierarchy@odata.bind' as key");
         }

package/src/objects/User.ts

@@ -1,14 +1,18 @@
 import { TM1Object } from './TM1Object';
-import { CaseAndSpaceInsensitiveSet, formatUrl } from '../utils/Utils';
+import { CaseAndSpaceInsensitiveSet, formatUrl, lowerAndDropSpaces } from '../utils/Utils';
 
 export enum UserType {
-    User = 0,
-    SecurityAdmin = 1,
-    DataAdmin = 2,
-    Admin = 3,
-    OperationsAdmin = 4
+    User = 'User',
+    SecurityAdmin = 'SecurityAdmin',
+    DataAdmin = 'DataAdmin',
+    Admin = 'Admin',
+    OperationsAdmin = 'OperationsAdmin'
 }
 
+const USER_TYPE_LOOKUP = new Map<string, UserType>(
+    Object.entries(UserType).map(([k, v]) => [k.toLowerCase(), v as UserType])
+);
+
 export class User extends TM1Object {
     /** Abstraction of a TM1 User
      * 
@@ -70,25 +74,15 @@ export class User extends TM1Object {
     }
 
     public set userType(value: UserType | string) {
-        if (typeof value === 'string') {
-            // Parse string to UserType enum
-            const lowerValue = value.replace(/\s+/g, '').toLowerCase();
-            for (const [key, enumValue] of Object.entries(UserType)) {
-                if (key.toLowerCase() === lowerValue) {
-                    this._userType = enumValue as UserType;
-                    break;
-                }
-            }
-            if (this._userType === undefined) {
-                throw new Error(`Invalid element type=${value}`);
-            }
-        } else {
-            this._userType = value;
+        const resolved = USER_TYPE_LOOKUP.get(lowerAndDropSpaces(value));
+        if (resolved === undefined) {
+            throw new Error(`Invalid user type=${value}`);
         }
+        this._userType = resolved;
 
         // update groups as well, since TM1 doesn't react to change in user_type property
         if (this._userType !== UserType.User) {
-            this.addGroup(this._userType.toString());
+            this.addGroup(this._userType);
         }
     }
 
@@ -109,7 +103,7 @@ export class User extends TM1Object {
     }
 
     public get isAdmin(): boolean {
-        return this._groups.has("ADMIN");
+        return this._groups.has("Admin");
     }
 
     public get isDataAdmin(): boolean {
@@ -165,7 +159,7 @@ export class User extends TM1Object {
             userAsDict.Groups.map((group: any) => group.Name),
             userAsDict.FriendlyName,
             undefined, // password not included in dict
-            userAsDict.Type,
+            userAsDict.Type ?? undefined,
             userAsDict.Enabled
         );
     }

package/src/tests/debuggerService.test.ts

@@ -370,7 +370,9 @@ describe('DebuggerService and Enhanced Process Debugging (Issue #13)', () => {
                 expect(plan.hasVariables).toBe(true);
                 expect(plan.variableCount).toBe(1);
                 expect(plan.procedures.hasPrologProcedure).toBe(true);
-                expect(plan.estimatedComplexity).toBe('Medium');
+                // addGeneratedStringToCode prepends ~73 chars to each procedure tab,
+                // so actual total exceeds 2000 → 'High'
+                expect(plan.estimatedComplexity).toBe('High');
             });
         });
     });