tm1npm 1.0.0

package/src/services/RestService.ts

@@ -0,0 +1,224 @@
+import axios, { AxiosInstance, AxiosResponse, AxiosRequestConfig } from 'axios';
+import { TM1RestException, TM1TimeoutException } from '../exceptions/TM1Exception';
+
+export enum AuthenticationMode {
+    BASIC = 1,
+    WIA = 2,
+    CAM = 3,
+    CAM_SSO = 4,
+    IBM_CLOUD_API_KEY = 5,
+    SERVICE_TO_SERVICE = 6,
+    PA_PROXY = 7,
+    BASIC_API_KEY = 8,
+    ACCESS_TOKEN = 9
+}
+
+export interface RestServiceConfig {
+    address?: string;
+    port?: number;
+    ssl?: boolean;
+    baseUrl?: string;
+    user?: string;
+    password?: string;
+    decodeB64?: boolean;
+    namespace?: string;
+    sessionId?: string;
+    sessionContext?: string;
+    verify?: boolean | string;
+    timeout?: number;
+    cancelAtTimeout?: boolean;
+    asyncRequestsMode?: boolean;
+    connectionPoolSize?: number;
+    poolConnections?: number;
+    instance?: string;
+    database?: string;
+    authUrl?: string;
+    camPassport?: string;
+    applicationClientId?: string;
+    applicationClientSecret?: string;
+    apiKey?: string;
+    accessToken?: string;
+    tenant?: string;
+}
+
+export class RestService {
+    private static readonly HEADERS = {
+        'Connection': 'keep-alive',
+        'User-Agent': 'tm1npm',
+        'Content-Type': 'application/json; odata.streaming=true; charset=utf-8',
+        'Accept': 'application/json;odata.metadata=none,text/plain',
+        'TM1-SessionContext': 'tm1npm'
+    };
+
+    private static readonly DEFAULT_CONNECTION_POOL_SIZE = 10;
+    private static readonly DEFAULT_POOL_CONNECTIONS = 1;
+
+    private axiosInstance!: AxiosInstance;
+    private config: RestServiceConfig;
+    private sessionId?: string;
+    private sandboxName?: string;
+    private isConnected: boolean = false;
+    public version?: string;
+
+    constructor(config: RestServiceConfig) {
+        this.config = { ...config };
+        this.setupAxiosInstance();
+    }
+
+    private setupAxiosInstance(): void {
+        const baseURL = this.buildBaseUrl();
+        
+        this.axiosInstance = axios.create({
+            baseURL,
+            timeout: (this.config.timeout || 60) * 1000,
+            headers: {
+                ...RestService.HEADERS,
+                ...(this.config.sessionContext && { 'TM1-SessionContext': this.config.sessionContext })
+            }
+        });
+
+        this.setupInterceptors();
+    }
+
+    private buildBaseUrl(): string {
+        if (this.config.baseUrl) {
+            return this.config.baseUrl;
+        }
+
+        const protocol = this.config.ssl ? 'https' : 'http';
+        const address = this.config.address || 'localhost';
+        const port = this.config.port || 8001;
+        
+        return `${protocol}://${address}:${port}/api/v1`;
+    }
+
+    private setupInterceptors(): void {
+        // Request interceptor
+        this.axiosInstance.interceptors.request.use(
+            (config) => {
+                if (this.sessionId) {
+                    config.headers['TM1SessionId'] = this.sessionId;
+                }
+                if (this.sandboxName) {
+                    config.headers['TM1-Sandbox'] = this.sandboxName;
+                }
+                return config;
+            },
+            (error) => Promise.reject(error)
+        );
+
+        // Response interceptor
+        this.axiosInstance.interceptors.response.use(
+            (response) => response,
+            (error) => {
+                if (error.code === 'ECONNABORTED' || error.message.includes('timeout')) {
+                    throw new TM1TimeoutException(`Request timeout: ${error.message}`);
+                }
+                
+                const response = error.response;
+                if (response) {
+                    const message = this.extractErrorMessage(response);
+                    throw new TM1RestException(message, response);
+                }
+                
+                throw new TM1RestException(error.message);
+            }
+        );
+    }
+
+    private extractErrorMessage(response: AxiosResponse): string {
+        try {
+            if (response.data && response.data.error) {
+                if (response.data.error.message) {
+                    return response.data.error.message;
+                }
+                return JSON.stringify(response.data.error);
+            }
+            return `HTTP ${response.status}: ${response.statusText}`;
+        } catch {
+            return `HTTP ${response.status}: ${response.statusText}`;
+        }
+    }
+
+    public async connect(): Promise<void> {
+        try {
+            // Basic authentication
+            if (this.config.user && this.config.password) {
+                const credentials = Buffer.from(`${this.config.user}:${this.config.password}`).toString('base64');
+                this.axiosInstance.defaults.headers.common['Authorization'] = `Basic ${credentials}`;
+            }
+
+            // Test connection
+            const response = await this.axiosInstance.get('/Configuration/ServerName');
+            
+            // Extract session ID from response headers
+            const setCookie = response.headers['set-cookie'];
+            if (setCookie) {
+                for (const cookie of setCookie) {
+                    const match = cookie.match(/TM1SessionId=([^;]+)/);
+                    if (match) {
+                        this.sessionId = match[1];
+                        break;
+                    }
+                }
+            }
+
+            this.isConnected = true;
+        } catch (error) {
+            throw new TM1RestException(`Failed to connect to TM1: ${error}`);
+        }
+    }
+
+    public async disconnect(): Promise<void> {
+        if (this.isConnected && this.sessionId) {
+            try {
+                await this.axiosInstance.post('/ActiveSession/tm1.Close', {});
+            } catch (error) {
+                // Ignore errors during disconnect
+            }
+            this.isConnected = false;
+            this.sessionId = undefined;
+        }
+    }
+
+    public async get(url: string, config?: AxiosRequestConfig): Promise<AxiosResponse> {
+        return this.axiosInstance.get(url, config);
+    }
+
+    public async post(url: string, data?: any, config?: AxiosRequestConfig): Promise<AxiosResponse> {
+        return this.axiosInstance.post(url, data, config);
+    }
+
+    public async patch(url: string, data?: any, config?: AxiosRequestConfig): Promise<AxiosResponse> {
+        return this.axiosInstance.patch(url, data, config);
+    }
+
+    public async put(url: string, data?: any, config?: AxiosRequestConfig): Promise<AxiosResponse> {
+        return this.axiosInstance.put(url, data, config);
+    }
+
+    public async delete(url: string, config?: AxiosRequestConfig): Promise<AxiosResponse> {
+        return this.axiosInstance.delete(url, config);
+    }
+
+    public getSessionId(): string | undefined {
+        return this.sessionId;
+    }
+
+    public setSandbox(sandboxName?: string): void {
+        this.sandboxName = sandboxName;
+    }
+
+    public getSandbox(): string | undefined {
+        return this.sandboxName;
+    }
+
+    public isLoggedIn(): boolean {
+        return this.isConnected && !!this.sessionId;
+    }
+
+    public async getApiMetadata(): Promise<any> {
+        const response = await this.get("/$metadata");
+        return response.data;
+    }
+}

package/src/services/SandboxService.ts

@@ -0,0 +1,217 @@
+import { AxiosResponse } from 'axios';
+import { RestService } from './RestService';
+import { ObjectService } from './ObjectService';
+import { Sandbox } from '../objects/Sandbox';
+import { TM1RestException } from '../exceptions/TM1Exception';
+import { formatUrl } from '../utils/Utils';
+
+export class SandboxService extends ObjectService {
+    /** Service to handle sandboxes in TM1
+     * 
+     */
+
+    constructor(rest: RestService) {
+        super(rest);
+    }
+
+    public async get(sandboxName: string): Promise<Sandbox> {
+        /** get a sandbox from TM1 Server
+         *
+         * :param sandbox_name: str
+         * :return: instance of .Sandbox
+         */
+        const url = formatUrl("/Sandboxes('{}')", sandboxName);
+        const response = await this.rest.get(url);
+        const sandbox = Sandbox.fromJSON(JSON.stringify(response.data));
+        return sandbox;
+    }
+
+    public async getAll(): Promise<Sandbox[]> {
+        /** get all sandboxes from TM1 Server
+         *
+         * :return: List of .Sandbox instances
+         */
+        const url = "/Sandboxes?$select=Name,IncludeInSandboxDimension,IsLoaded,IsActive,IsQueued";
+        const response = await this.rest.get(url);
+        const sandboxes = response.data.value.map((sandboxAsDict: any) =>
+            Sandbox.fromDict(sandboxAsDict)
+        );
+        return sandboxes;
+    }
+
+    public async getAllNames(): Promise<string[]> {
+        /** get all sandbox names
+         *
+         * :param kwargs:
+         * :return:
+         */
+        const url = "/Sandboxes?$select=Name";
+        const response = await this.rest.get(url);
+        return response.data.value.map((entry: any) => entry.Name);
+    }
+
+    public async create(sandbox: Sandbox): Promise<AxiosResponse> {
+        /** create a new sandbox in TM1 Server
+         *
+         * :param sandbox: Sandbox
+         * :return: response
+         */
+        const url = "/Sandboxes";
+        return await this.rest.post(url, sandbox.body);
+    }
+
+    public async update(sandbox: Sandbox): Promise<AxiosResponse> {
+        /** update a sandbox in TM1
+         *
+         * :param sandbox:
+         * :return: response
+         */
+        const url = formatUrl("/Sandboxes('{}')", sandbox.name);
+        return await this.rest.patch(url, sandbox.body);
+    }
+
+    public async delete(sandboxName: string): Promise<AxiosResponse> {
+        /** delete a sandbox in TM1
+         *
+         * :param sandbox_name:
+         * :return: response
+         */
+        const url = formatUrl("/Sandboxes('{}')", sandboxName);
+        return await this.rest.delete(url);
+    }
+
+    public async publish(sandboxName: string): Promise<AxiosResponse> {
+        /** publish existing sandbox to base
+         *
+         * :param sandbox_name: str
+         * :return: response
+         */
+        const url = formatUrl("/Sandboxes('{}')/tm1.Publish", sandboxName);
+        return await this.rest.post(url, "{}");
+    }
+
+    public async reset(sandboxName: string): Promise<AxiosResponse> {
+        /** reset all changes in specified sandbox
+         *
+         * :param sandbox_name: str
+         * :return: response
+         */
+        const url = formatUrl("/Sandboxes('{}')/tm1.DiscardChanges", sandboxName);
+        return await this.rest.post(url, "{}");
+    }
+
+    public async merge(sourceSandboxName: string, targetSandboxName: string): Promise<AxiosResponse> {
+        /** merge changes from source sandbox into target sandbox
+         *
+         * :param source_sandbox_name: str
+         * :param target_sandbox_name: str
+         * :return: response
+         */
+        const url = formatUrl("/Sandboxes('{}')/tm1.Merge", targetSandboxName);
+        const body = {
+            "Source@odata.bind": `Sandboxes('${sourceSandboxName}')`
+        };
+        return await this.rest.post(url, JSON.stringify(body));
+    }
+
+    public async exists(sandboxName: string): Promise<boolean> {
+        /** check if sandbox exists
+         *
+         * :param sandbox_name: str
+         * :return: boolean
+         */
+        try {
+            await this.get(sandboxName);
+            return true;
+        } catch (error) {
+            if (error instanceof TM1RestException && error.statusCode === 404) {
+                return false;
+            }
+            throw error;
+        }
+    }
+
+    public async getChanges(sandboxName: string): Promise<any> {
+        /** get all changes in a sandbox
+         *
+         * :param sandbox_name: str
+         * :return: dict of changes
+         */
+        const url = formatUrl("/Sandboxes('{}')/Changes", sandboxName);
+        const response = await this.rest.get(url);
+        return response.data;
+    }
+
+    public async isEmpty(sandboxName: string): Promise<boolean> {
+        /** check if sandbox is empty (has no changes)
+         *
+         * :param sandbox_name: str
+         * :return: boolean
+         */
+        try {
+            const changes = await this.getChanges(sandboxName);
+            return !changes || !changes.value || changes.value.length === 0;
+        } catch {
+            return true;
+        }
+    }
+
+    public async load(sandboxName: string): Promise<AxiosResponse> {
+        /** load sandbox into memory
+         *
+         * :param sandbox_name: str
+         * :return: response
+         */
+        const url = formatUrl("/Sandboxes('{}')/tm1.Load", sandboxName);
+        return await this.rest.post(url, "{}");
+    }
+
+    public async unload(sandboxName: string): Promise<AxiosResponse> {
+        /** unload sandbox from memory
+         *
+         * :param sandbox_name: str
+         * :return: response
+         */
+        const url = formatUrl("/Sandboxes('{}')/tm1.Unload", sandboxName);
+        return await this.rest.post(url, "{}");
+    }
+
+    public async getSandboxDimensionMembers(): Promise<string[]> {
+        /** get all members of the }Sandboxes dimension
+         *
+         * :return: list of sandbox names
+         */
+        const url = "/Dimensions('}Sandboxes')/Hierarchies('}Sandboxes')/Elements?$select=Name";
+        const response = await this.rest.get(url);
+        return response.data.value.map((element: any) => element.Name);
+    }
+
+    public async createIfNotExists(sandbox: Sandbox): Promise<AxiosResponse | null> {
+        /** create sandbox if it doesn't exist
+         *
+         * :param sandbox: Sandbox instance
+         * :return: response or null if already exists
+         */
+        if (await this.exists(sandbox.name)) {
+            return null;
+        }
+        return await this.create(sandbox);
+    }
+
+    public async cloneSandbox(sourceSandboxName: string, targetSandboxName: string): Promise<AxiosResponse> {
+        /** clone a sandbox
+         *
+         * :param source_sandbox_name: str
+         * :param target_sandbox_name: str
+         * :return: response
+         */
+        const sourceSandbox = await this.get(sourceSandboxName);
+        const targetSandbox = new Sandbox(
+            targetSandboxName,
+            sourceSandbox.includeInSandboxDimension
+        );
+        
+        await this.create(targetSandbox);
+        return await this.merge(sourceSandboxName, targetSandboxName);
+    }
+}