tm1npm 1.0.0

package/lib/utils/Utils.js

@@ -0,0 +1,379 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Utils = exports.HTTPAdapterWithSocketOptions = exports.CaseAndSpaceInsensitiveSet = exports.CaseAndSpaceInsensitiveMap = exports.CaseAndSpaceInsensitiveTuplesDict = exports.CaseAndSpaceInsensitiveDict = void 0;
+exports.caseAndSpaceInsensitiveEquals = caseAndSpaceInsensitiveEquals;
+exports.lowerAndDropSpaces = lowerAndDropSpaces;
+exports.formatUrl = formatUrl;
+exports.extractCellsetCells = extractCellsetCells;
+exports.buildMdxFromAxes = buildMdxFromAxes;
+exports.buildElementsStringFromIterable = buildElementsStringFromIterable;
+exports.dimensionHierarchyElementTupleFromUniqueName = dimensionHierarchyElementTupleFromUniqueName;
+exports.buildElementUniqueNames = buildElementUniqueNames;
+exports.dimensionHierarchyElementTupleFromString = dimensionHierarchyElementTupleFromString;
+exports.deprecatedInVersion = deprecatedInVersion;
+exports.requireVersion = requireVersion;
+exports.requireAdmin = requireAdmin;
+exports.requireDataAdmin = requireDataAdmin;
+exports.requireSecurityAdmin = requireSecurityAdmin;
+exports.requireOpsAdmin = requireOpsAdmin;
+exports.wrapTupleInBrackets = wrapTupleInBrackets;
+exports.abbreviateString = abbreviateString;
+exports.getTimeFromTimeStamp = getTimeFromTimeStamp;
+exports.addTimeToTimeStamp = addTimeToTimeStamp;
+exports.tidy = tidy;
+exports.getMdxElementFromAttribute = getMdxElementFromAttribute;
+exports.buildMdxTuple = buildMdxTuple;
+exports.verifyVersion = verifyVersion;
+exports.readObjectNameFromUrl = readObjectNameFromUrl;
+exports.integerizeVersion = integerizeVersion;
+exports.frameToSignificantValue = frameToSignificantValue;
+exports.odataTrackChangesHeader = odataTrackChangesHeader;
+exports.utcLocalizeTime = utcLocalizeTime;
+exports.decohints = decohints;
+class CaseAndSpaceInsensitiveDict extends Map {
+    normalizeKey(key) {
+        return key.toLowerCase().replace(/\s+/g, '');
+    }
+    set(key, value) {
+        return super.set(this.normalizeKey(key), value);
+    }
+    get(key) {
+        return super.get(this.normalizeKey(key));
+    }
+    has(key) {
+        return super.has(this.normalizeKey(key));
+    }
+    delete(key) {
+        return super.delete(this.normalizeKey(key));
+    }
+}
+exports.CaseAndSpaceInsensitiveDict = CaseAndSpaceInsensitiveDict;
+class CaseAndSpaceInsensitiveTuplesDict extends Map {
+    normalizeKey(key) {
+        return key.toLowerCase().replace(/\s+/g, '');
+    }
+    set(key, value) {
+        return super.set(this.normalizeKey(key), value);
+    }
+    get(key) {
+        return super.get(this.normalizeKey(key));
+    }
+    has(key) {
+        return super.has(this.normalizeKey(key));
+    }
+    delete(key) {
+        return super.delete(this.normalizeKey(key));
+    }
+}
+exports.CaseAndSpaceInsensitiveTuplesDict = CaseAndSpaceInsensitiveTuplesDict;
+class CaseAndSpaceInsensitiveMap extends Map {
+    normalizeKey(key) {
+        return key.toLowerCase().replace(/\s+/g, '');
+    }
+    set(key, value) {
+        return super.set(this.normalizeKey(key), value);
+    }
+    get(key) {
+        return super.get(this.normalizeKey(key));
+    }
+    has(key) {
+        return super.has(this.normalizeKey(key));
+    }
+    delete(key) {
+        return super.delete(this.normalizeKey(key));
+    }
+}
+exports.CaseAndSpaceInsensitiveMap = CaseAndSpaceInsensitiveMap;
+class CaseAndSpaceInsensitiveSet extends Set {
+    normalizeValue(value) {
+        return value.toLowerCase().replace(/\s+/g, '');
+    }
+    add(value) {
+        return super.add(this.normalizeValue(value));
+    }
+    has(value) {
+        return super.has(this.normalizeValue(value));
+    }
+    delete(value) {
+        return super.delete(this.normalizeValue(value));
+    }
+}
+exports.CaseAndSpaceInsensitiveSet = CaseAndSpaceInsensitiveSet;
+function caseAndSpaceInsensitiveEquals(str1, str2) {
+    if (str1 === str2)
+        return true;
+    if (!str1 || !str2)
+        return false;
+    return str1.toLowerCase().replace(/\s+/g, '') ===
+        str2.toLowerCase().replace(/\s+/g, '');
+}
+function lowerAndDropSpaces(str) {
+    return str.toLowerCase().replace(/\s+/g, '');
+}
+function formatUrl(template, ...args) {
+    let url = template;
+    for (const arg of args) {
+        url = url.replace('{}', encodeURIComponent(arg));
+    }
+    return url;
+}
+function extractCellsetCells(cellset) {
+    if (!cellset || !cellset.Cells) {
+        return [];
+    }
+    return cellset.Cells;
+}
+function buildMdxFromAxes(axes) {
+    // Simple MDX builder - can be expanded
+    if (!axes || axes.length === 0) {
+        return '';
+    }
+    let mdx = 'SELECT ';
+    for (let i = 0; i < axes.length; i++) {
+        if (i > 0)
+            mdx += ', ';
+        const axis = axes[i];
+        if (axis.Tuples && axis.Tuples.length > 0) {
+            const members = axis.Tuples.map((tuple) => {
+                if (tuple.Members) {
+                    return tuple.Members.map((member) => `[${member.UniqueName}]`).join(',');
+                }
+                return '';
+            }).join(',');
+            mdx += `{${members}} ON ${i}`;
+        }
+        else {
+            mdx += `{} ON ${i}`;
+        }
+    }
+    return mdx;
+}
+function buildElementsStringFromIterable(elements, separator = ',') {
+    return Array.from(elements).join(separator);
+}
+function dimensionHierarchyElementTupleFromUniqueName(uniqueName) {
+    // Parse [Dimension].[Hierarchy].[Element] format
+    const matches = uniqueName.match(/\[([^\]]+)\]\.\[([^\]]+)\]\.\[([^\]]+)\]/);
+    if (matches && matches.length === 4) {
+        return [matches[1], matches[2], matches[3]];
+    }
+    // Fallback: assume format is Dimension.Hierarchy.Element
+    const parts = uniqueName.split('.');
+    if (parts.length >= 3) {
+        return [parts[0], parts[1], parts[2]];
+    }
+    else if (parts.length === 2) {
+        return [parts[0], parts[0], parts[1]]; // Default hierarchy = dimension name
+    }
+    else {
+        return [uniqueName, uniqueName, uniqueName];
+    }
+}
+function buildElementUniqueNames(elements, dimensionName, hierarchyName) {
+    const hierarchy = hierarchyName || dimensionName;
+    return elements.map(element => `[${dimensionName}].[${hierarchy}].[${element}]`);
+}
+function dimensionHierarchyElementTupleFromString(dimensionHierarchyElement) {
+    // Parse [Dimension].[Hierarchy].[Element] format
+    const matches = dimensionHierarchyElement.match(/\[([^\]]+)\]\.\[([^\]]+)\]\.\[([^\]]+)\]/);
+    if (matches && matches.length === 4) {
+        return [matches[1], matches[2], matches[3]];
+    }
+    // Fallback: assume format is Dimension.Hierarchy.Element
+    const parts = dimensionHierarchyElement.split('.');
+    if (parts.length >= 3) {
+        return [parts[0], parts[1], parts[2]];
+    }
+    else if (parts.length === 2) {
+        return [parts[0], parts[0], parts[1]]; // Default hierarchy = dimension name
+    }
+    else {
+        return [dimensionHierarchyElement, dimensionHierarchyElement, dimensionHierarchyElement];
+    }
+}
+function deprecatedInVersion(version) {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = function (...args) {
+            console.warn(`Method ${propertyKey} is deprecated in version ${version}`);
+            return originalMethod.apply(this, args);
+        };
+    };
+}
+function requireVersion(minVersion) {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = function (...args) {
+            // Version check would be implemented here
+            // For now, just call the original method
+            return originalMethod.apply(this, args);
+        };
+    };
+}
+function requireAdmin(target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    descriptor.value = function (...args) {
+        // Admin check would be implemented here
+        // For now, just call the original method
+        return originalMethod.apply(this, args);
+    };
+}
+function requireDataAdmin(target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    descriptor.value = function (...args) {
+        // Data admin check would be implemented here
+        // For now, just call the original method
+        return originalMethod.apply(this, args);
+    };
+}
+function requireSecurityAdmin(target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    descriptor.value = function (...args) {
+        // Security admin check would be implemented here
+        // For now, just call the original method
+        return originalMethod.apply(this, args);
+    };
+}
+function requireOpsAdmin(target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    descriptor.value = function (...args) {
+        // Ops admin check would be implemented here
+        // For now, just call the original method
+        return originalMethod.apply(this, args);
+    };
+}
+function wrapTupleInBrackets(members) {
+    if (members.length === 1) {
+        return `[${members[0]}]`;
+    }
+    return `(${members.map(m => `[${m}]`).join(',')})`;
+}
+function abbreviateString(text, maxLength) {
+    if (!text || text.length <= maxLength) {
+        return text || '';
+    }
+    if (maxLength <= 3) {
+        return '...';
+    }
+    return text.substring(0, maxLength - 3) + '...';
+}
+function getTimeFromTimeStamp(timestamp) {
+    // Parse various timestamp formats
+    try {
+        return new Date(timestamp);
+    }
+    catch (error) {
+        // Try parsing as ISO string or other formats
+        return new Date();
+    }
+}
+function addTimeToTimeStamp(timestamp, hours) {
+    const date = getTimeFromTimeStamp(timestamp);
+    date.setHours(date.getHours() + hours);
+    return date.toISOString();
+}
+function tidy(inputString) {
+    if (!inputString)
+        return '';
+    return inputString.trim().replace(/\s+/g, ' ');
+}
+// MDX Utility functions
+function getMdxElementFromAttribute(attribute, cube) {
+    return `[${cube}].[${attribute}]`;
+}
+function buildMdxTuple(members) {
+    if (members.length === 1) {
+        return members[0];
+    }
+    return `(${members.join(',')})`;
+}
+// Verification utilities
+function verifyVersion(actualVersion, requiredVersion) {
+    // Handle null/undefined inputs
+    if (!actualVersion || !requiredVersion) {
+        return false;
+    }
+    // Simple version comparison
+    const actual = actualVersion.split('.').map(Number);
+    const required = requiredVersion.split('.').map(Number);
+    for (let i = 0; i < Math.max(actual.length, required.length); i++) {
+        const a = actual[i] || 0;
+        const r = required[i] || 0;
+        if (a > r)
+            return true;
+        if (a < r)
+            return false;
+    }
+    return true; // Equal versions
+}
+function readObjectNameFromUrl(url) {
+    // Extract object name from URL like "/Dimensions('DimName')" -> "DimName"
+    const match = url.match(/\('([^']+)'\)/);
+    return match ? match[1] : '';
+}
+function integerizeVersion(version) {
+    // Convert version string like "11.8.01300.1" to integer like 1180
+    const parts = version.split('.');
+    const major = parseInt(parts[0]) || 0;
+    const minor = parseInt(parts[1]) || 0;
+    return major * 100 + minor;
+}
+// Frame utilities for working with tabular data
+function frameToSignificantValue(value) {
+    if (typeof value === 'number') {
+        if (Math.abs(value) < 1e-10) {
+            return 0;
+        }
+        return Number(value.toPrecision(10));
+    }
+    return value;
+}
+// HTTP utilities
+class HTTPAdapterWithSocketOptions {
+    constructor(socketOptions = {}) {
+        this.socketOptions = socketOptions;
+    }
+}
+exports.HTTPAdapterWithSocketOptions = HTTPAdapterWithSocketOptions;
+// Additional utility functions
+function odataTrackChangesHeader() {
+    return {
+        'Prefer': 'return=representation;odata.track-changes'
+    };
+}
+function utcLocalizeTime(utcTimeStr) {
+    return new Date(utcTimeStr + 'Z');
+}
+function decohints() {
+    return 'decohints';
+}
+exports.Utils = {
+    CaseAndSpaceInsensitiveMap,
+    CaseAndSpaceInsensitiveSet,
+    caseAndSpaceInsensitiveEquals,
+    lowerAndDropSpaces,
+    formatUrl,
+    extractCellsetCells,
+    buildMdxFromAxes,
+    buildElementsStringFromIterable,
+    dimensionHierarchyElementTupleFromString,
+    requireVersion,
+    requireAdmin,
+    requireDataAdmin,
+    requireSecurityAdmin,
+    requireOpsAdmin,
+    wrapTupleInBrackets,
+    abbreviateString,
+    getTimeFromTimeStamp,
+    addTimeToTimeStamp,
+    tidy,
+    getMdxElementFromAttribute,
+    buildMdxTuple,
+    verifyVersion,
+    frameToSignificantValue,
+    HTTPAdapterWithSocketOptions,
+    odataTrackChangesHeader,
+    utcLocalizeTime,
+    decohints
+};
+//# sourceMappingURL=Utils.js.map

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "tm1npm",
+  "version": "1.0.0",
+  "description": "A Node.js module for TM1",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "test:ci": "jest --config jest.ci.config.js",
+    "test:coverage:ci": "jest --config jest.ci.config.js --coverage",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "test:verbose": "VERBOSE_TESTS=true jest --verbose",
+    "test:connection": "ts-node tests/connection/test-connection.ts",
+    "test:simple": "ts-node tests/connection/simple-connection-test.ts",
+    "test:minimal": "ts-node tests/connection/minimal-connection-test.ts",
+    "test:working": "ts-node tests/integration/working-test.ts",
+    "test:security": "ts-node tests/security/security-test.ts",
+    "test:performance": "ts-node tests/performance/performance-test.ts",
+    "test:edge-cases": "ts-node tests/edge-cases/edge-cases-test.ts",
+    "test:process-service": "jest src/tests/processService.test.ts",
+    "test:dimension-service": "jest src/tests/dimensionService.test.ts",
+    "test:cube-service": "jest src/tests/cubeService.test.ts",
+    "test:rest-service": "jest src/tests/restService.test.ts",
+    "test:subset-service": "jest src/tests/subsetService.test.ts",
+    "test:view-service": "jest src/tests/viewService.test.ts",
+    "test:element-service": "jest src/tests/elementService.test.ts",
+    "test:hierarchy-service": "jest src/tests/hierarchyService.test.ts",
+    "test:cell-service": "jest src/tests/cellService.test.ts",
+    "test:comprehensive": "jest src/tests/comprehensive.service.test.ts",
+    "test:security-advanced": "jest src/tests/security.advanced.test.ts",
+    "test:mdx-advanced": "jest src/tests/mdx.advanced.test.ts",
+    "test:stress-performance": "jest src/tests/stress.performance.test.ts",
+    "test:services": "jest src/tests/*Service.test.ts",
+    "test:advanced": "jest src/tests/*.advanced.test.ts",
+    "test:all": "node run-all-tests.js",
+    "test:all-bash": "./run-all-tests.sh",
+    "test:full-suite": "npm run test:comprehensive && npm run test:security-advanced && npm run test:mdx-advanced && npm run test:stress-performance",
+    "lint": "eslint src/**/*.ts",
+    "lint:fix": "eslint src/**/*.ts --fix",
+    "prepare": "npm run build",
+    "clean": "rm -rf lib coverage",
+    "dev": "tsc --watch"
+  },
+  "keywords": [
+    "TM1",
+    "IBM Cognos TM1",
+    "Planning Analytics",
+    "PA",
+    "Cognos",
+    "REST API"
+  ],
+  "author": "KimKaoPoo",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^1.6.0",
+    "luxon": "^3.4.0",
+    "uuid": "^9.0.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.0.0",
+    "@types/node": "^20.0.0",
+    "@types/uuid": "^9.0.0",
+    "@typescript-eslint/eslint-plugin": "^6.0.0",
+    "@typescript-eslint/parser": "^6.0.0",
+    "dotenv": "^17.2.2",
+    "eslint": "^8.0.0",
+    "jest": "^29.0.0",
+    "ts-jest": "^29.0.0",
+    "ts-node": "^10.9.0",
+    "typescript": "^5.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/KimKaoPoo/tm1npm.git"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  }
+}