@sisense/sdk-common 2.5.0 → 2.7.0

package/dist/utils/url.js

@@ -0,0 +1,79 @@
+/**
+ * Normalizes a URL string by ensuring it has a trailing slash and optionally includes search parameters.
+ * @param url - The URL string to normalize
+ * @param includeSearchString - Whether to include search parameters in the result
+ * @returns The normalized URL string
+ * @throws Error if the URL is invalid, empty, or not a string
+ */
+export function normalizeUrl(url, includeSearchString) {
+    if (typeof url !== 'string') {
+        throw new Error('URL must be a string');
+    }
+    if (!url.trim()) {
+        throw new Error('URL cannot be empty');
+    }
+    try {
+        const urlObject = new URL(url);
+        return (urlObject.origin +
+            (urlObject.pathname.endsWith('/') ? urlObject.pathname : urlObject.pathname + '/') +
+            (includeSearchString && urlObject.search ? urlObject.search : ''));
+    }
+    catch (_a) {
+        throw new Error(`Connection string ${url} is not a valid URL`);
+    }
+}
+/**
+ * Merges two URLs, combining their paths and query parameters.
+ * If loginUrlStr is an absolute URL, it takes precedence over baseUrlStr.
+ * If loginUrlStr is relative, it's merged with baseUrlStr.
+ *
+ * @param baseUrlStr - The base URL to merge with
+ * @param loginUrlStr - The login URL (can be absolute or relative)
+ * @returns The merged URL string
+ * @throws Error if baseUrlStr is not a valid URL
+ */
+export function mergeUrlsWithParams(baseUrlStr, loginUrlStr) {
+    if (!baseUrlStr) {
+        throw new Error('Base URL is required');
+    }
+    // Parse base URL first to validate it
+    let baseUrl;
+    try {
+        baseUrl = new URL(baseUrlStr);
+    }
+    catch (_a) {
+        throw new Error('Base URL is not valid');
+    }
+    // If no login URL provided or it's just a slash, return base URL
+    if (!loginUrlStr || loginUrlStr === '/') {
+        return baseUrl.toString();
+    }
+    try {
+        // Check if loginUrlStr is an absolute URL
+        const loginUrl = new URL(loginUrlStr);
+        return loginUrl.toString();
+    }
+    catch (_b) {
+        // loginUrlStr is relative, proceed with merging
+    }
+    // Create a URL by joining base origin with login path
+    const resultUrl = new URL(baseUrl.toString());
+    // Split login URL into path and query parts
+    const [loginPath = '', loginQuery = ''] = loginUrlStr.split(/\?(.+)/);
+    // Handle the path merging
+    const basePath = baseUrl.pathname.replace(/\/$/, ''); // Remove trailing slash
+    const cleanLoginPath = loginPath
+        .replace(/^\/+/, '') // Remove leading slashes
+        .replace(/\/+$/, '') // Remove trailing slashes
+        .replace(/\/+/g, '/'); // Replace multiple slashes with single slash
+    resultUrl.pathname = cleanLoginPath ? `${basePath}/${cleanLoginPath}` : basePath;
+    // Parse and merge query parameters from both URLs
+    if (loginQuery) {
+        const loginParams = new URLSearchParams(loginQuery);
+        for (const [key, value] of loginParams.entries()) {
+            resultUrl.searchParams.set(key, value);
+        }
+    }
+    // Normalize the final URL by removing trailing slash
+    return normalizeUrl(resultUrl.toString(), true);
+}

package/dist/utils/url.test.js

@@ -0,0 +1,94 @@
+import { describe, expect, it } from 'vitest';
+import { mergeUrlsWithParams, normalizeUrl } from './url.js';
+describe('normalizeUrl', () => {
+    it("should add a trailing slash if url doesn't have it", () => {
+        expect(normalizeUrl('https://example.com')).toBe('https://example.com/');
+    });
+    it('should not add an extra trailing slash if url does have it', () => {
+        expect(normalizeUrl('https://example.com/')).toBe('https://example.com/');
+    });
+    it('should include search string when specified', () => {
+        expect(normalizeUrl('https://example.com?param=value', true)).toBe('https://example.com/?param=value');
+    });
+    it('should throw error for invalid URL', () => {
+        expect(() => normalizeUrl('not-a-url')).toThrow();
+    });
+    it('should throw error for empty string', () => {
+        expect(() => normalizeUrl('')).toThrow('URL cannot be empty');
+        expect(() => normalizeUrl('   ')).toThrow('URL cannot be empty');
+    });
+    it('should throw error for non-string input', () => {
+        // @ts-expect-error Testing runtime type check
+        expect(() => normalizeUrl(null)).toThrow('URL must be a string');
+        // @ts-expect-error Testing runtime type check
+        expect(() => normalizeUrl(undefined)).toThrow('URL must be a string');
+        // @ts-expect-error Testing runtime type check
+        expect(() => normalizeUrl(123)).toThrow('URL must be a string');
+    });
+});
+describe('mergeUrlsWithParams', () => {
+    describe('input validation', () => {
+        it('should throw error when base URL is not provided', () => {
+            expect(() => mergeUrlsWithParams('')).toThrow('Base URL is required');
+        });
+        it('should throw error when base URL is invalid', () => {
+            expect(() => mergeUrlsWithParams('not-a-url')).toThrow('Base URL is not valid');
+        });
+    });
+    describe('base URL handling', () => {
+        it('should return base URL when login URL is not provided', () => {
+            expect(mergeUrlsWithParams('https://example.com')).toBe('https://example.com/');
+        });
+        it('should return base URL when login URL is just a slash', () => {
+            expect(mergeUrlsWithParams('https://example.com', '/')).toBe('https://example.com/');
+        });
+        it('should preserve base URL port if specified', () => {
+            expect(mergeUrlsWithParams('https://example.com:8080', 'login')).toBe('https://example.com:8080/login/');
+        });
+    });
+    describe('absolute URL handling', () => {
+        it('should use absolute login URL when provided', () => {
+            expect(mergeUrlsWithParams('https://example.com', 'https://login.example.com/')).toBe('https://login.example.com/');
+        });
+        it('should preserve query params in absolute login URL', () => {
+            expect(mergeUrlsWithParams('https://example.com', 'https://login.example.com?token=123')).toBe('https://login.example.com/?token=123');
+        });
+    });
+    describe('relative path handling', () => {
+        it('should merge relative login path with base URL', () => {
+            expect(mergeUrlsWithParams('https://example.com', 'login')).toBe('https://example.com/login/');
+        });
+        it('should handle relative login path with leading slash', () => {
+            expect(mergeUrlsWithParams('https://example.com', '/login')).toBe('https://example.com/login/');
+        });
+        it('should handle relative login path with trailing slash', () => {
+            expect(mergeUrlsWithParams('https://example.com', 'login/')).toBe('https://example.com/login/');
+        });
+        it('should handle multiple slashes in path', () => {
+            expect(mergeUrlsWithParams('https://example.com', '//login///path//')).toBe('https://example.com/login/path/');
+        });
+    });
+    describe('query parameter handling', () => {
+        it('should merge query parameters from both URLs', () => {
+            expect(mergeUrlsWithParams('https://example.com?a=1', 'login?b=2')).toBe('https://example.com/login/?a=1&b=2');
+        });
+        it('should override base query parameters with login query parameters', () => {
+            expect(mergeUrlsWithParams('https://example.com?param=1', 'login?param=2')).toBe('https://example.com/login/?param=2');
+        });
+        it('should handle multiple question marks in login URL', () => {
+            expect(mergeUrlsWithParams('https://example.com', 'login?param1=1?param2=2')).toBe('https://example.com/login/?param1=1%3Fparam2%3D2');
+        });
+        it('should handle complex paths and query parameters', () => {
+            expect(mergeUrlsWithParams('https://example.com/api?token=123', '/auth/login/?user=test&scope=full')).toBe('https://example.com/api/auth/login/?token=123&user=test&scope=full');
+        });
+        it('should handle alternative SSO host with relative path', () => {
+            const result = mergeUrlsWithParams('http://sso.app.client.com/auth?app=staging', '/users/login/?tracking=true&role=view');
+            const url = new URL(result);
+            expect(url.origin).toBe('http://sso.app.client.com');
+            expect(url.pathname).toBe('/auth/users/login/');
+            expect(url.searchParams.get('app')).toBe('staging');
+            expect(url.searchParams.get('tracking')).toBe('true');
+            expect(url.searchParams.get('role')).toBe('view');
+        });
+    });
+});

package/package.json

@@ -11,7 +11,7 @@
     "Sisense",
     "Compose SDK"
   ],
-  "version": "2.5.0",
+  "version": "2.7.0",
   "type": "module",
   "exports": {
     ".": "./dist/index.js"

package/src/utils/index.ts

@@ -1,2 +1,2 @@
 export { escapeSingleQuotes } from './escapeSingleQuotes.js';
-export { normalizeUrl } from './normalizeUrl.js';
+export { mergeUrlsWithParams, normalizeUrl } from './url.js';

package/src/utils/url.test.ts

@@ -0,0 +1,148 @@
+import { describe, expect, it } from 'vitest';
+
+import { mergeUrlsWithParams, normalizeUrl } from './url.js';
+
+describe('normalizeUrl', () => {
+  it("should add a trailing slash if url doesn't have it", () => {
+    expect(normalizeUrl('https://example.com')).toBe('https://example.com/');
+  });
+
+  it('should not add an extra trailing slash if url does have it', () => {
+    expect(normalizeUrl('https://example.com/')).toBe('https://example.com/');
+  });
+
+  it('should include search string when specified', () => {
+    expect(normalizeUrl('https://example.com?param=value', true)).toBe(
+      'https://example.com/?param=value',
+    );
+  });
+
+  it('should throw error for invalid URL', () => {
+    expect(() => normalizeUrl('not-a-url')).toThrow();
+  });
+
+  it('should throw error for empty string', () => {
+    expect(() => normalizeUrl('')).toThrow('URL cannot be empty');
+    expect(() => normalizeUrl('   ')).toThrow('URL cannot be empty');
+  });
+
+  it('should throw error for non-string input', () => {
+    // @ts-expect-error Testing runtime type check
+    expect(() => normalizeUrl(null)).toThrow('URL must be a string');
+    // @ts-expect-error Testing runtime type check
+    expect(() => normalizeUrl(undefined)).toThrow('URL must be a string');
+    // @ts-expect-error Testing runtime type check
+    expect(() => normalizeUrl(123)).toThrow('URL must be a string');
+  });
+});
+
+describe('mergeUrlsWithParams', () => {
+  describe('input validation', () => {
+    it('should throw error when base URL is not provided', () => {
+      expect(() => mergeUrlsWithParams('')).toThrow('Base URL is required');
+    });
+
+    it('should throw error when base URL is invalid', () => {
+      expect(() => mergeUrlsWithParams('not-a-url')).toThrow('Base URL is not valid');
+    });
+  });
+
+  describe('base URL handling', () => {
+    it('should return base URL when login URL is not provided', () => {
+      expect(mergeUrlsWithParams('https://example.com')).toBe('https://example.com/');
+    });
+
+    it('should return base URL when login URL is just a slash', () => {
+      expect(mergeUrlsWithParams('https://example.com', '/')).toBe('https://example.com/');
+    });
+
+    it('should preserve base URL port if specified', () => {
+      expect(mergeUrlsWithParams('https://example.com:8080', 'login')).toBe(
+        'https://example.com:8080/login/',
+      );
+    });
+  });
+
+  describe('absolute URL handling', () => {
+    it('should use absolute login URL when provided', () => {
+      expect(mergeUrlsWithParams('https://example.com', 'https://login.example.com/')).toBe(
+        'https://login.example.com/',
+      );
+    });
+
+    it('should preserve query params in absolute login URL', () => {
+      expect(
+        mergeUrlsWithParams('https://example.com', 'https://login.example.com?token=123'),
+      ).toBe('https://login.example.com/?token=123');
+    });
+  });
+
+  describe('relative path handling', () => {
+    it('should merge relative login path with base URL', () => {
+      expect(mergeUrlsWithParams('https://example.com', 'login')).toBe(
+        'https://example.com/login/',
+      );
+    });
+
+    it('should handle relative login path with leading slash', () => {
+      expect(mergeUrlsWithParams('https://example.com', '/login')).toBe(
+        'https://example.com/login/',
+      );
+    });
+
+    it('should handle relative login path with trailing slash', () => {
+      expect(mergeUrlsWithParams('https://example.com', 'login/')).toBe(
+        'https://example.com/login/',
+      );
+    });
+
+    it('should handle multiple slashes in path', () => {
+      expect(mergeUrlsWithParams('https://example.com', '//login///path//')).toBe(
+        'https://example.com/login/path/',
+      );
+    });
+  });
+
+  describe('query parameter handling', () => {
+    it('should merge query parameters from both URLs', () => {
+      expect(mergeUrlsWithParams('https://example.com?a=1', 'login?b=2')).toBe(
+        'https://example.com/login/?a=1&b=2',
+      );
+    });
+
+    it('should override base query parameters with login query parameters', () => {
+      expect(mergeUrlsWithParams('https://example.com?param=1', 'login?param=2')).toBe(
+        'https://example.com/login/?param=2',
+      );
+    });
+
+    it('should handle multiple question marks in login URL', () => {
+      expect(mergeUrlsWithParams('https://example.com', 'login?param1=1?param2=2')).toBe(
+        'https://example.com/login/?param1=1%3Fparam2%3D2',
+      );
+    });
+
+    it('should handle complex paths and query parameters', () => {
+      expect(
+        mergeUrlsWithParams(
+          'https://example.com/api?token=123',
+          '/auth/login/?user=test&scope=full',
+        ),
+      ).toBe('https://example.com/api/auth/login/?token=123&user=test&scope=full');
+    });
+
+    it('should handle alternative SSO host with relative path', () => {
+      const result = mergeUrlsWithParams(
+        'http://sso.app.client.com/auth?app=staging',
+        '/users/login/?tracking=true&role=view',
+      );
+      const url = new URL(result);
+
+      expect(url.origin).toBe('http://sso.app.client.com');
+      expect(url.pathname).toBe('/auth/users/login/');
+      expect(url.searchParams.get('app')).toBe('staging');
+      expect(url.searchParams.get('tracking')).toBe('true');
+      expect(url.searchParams.get('role')).toBe('view');
+    });
+  });
+});

package/src/utils/url.ts

@@ -0,0 +1,91 @@
+/**
+ * Normalizes a URL string by ensuring it has a trailing slash and optionally includes search parameters.
+ * @param url - The URL string to normalize
+ * @param includeSearchString - Whether to include search parameters in the result
+ * @returns The normalized URL string
+ * @throws Error if the URL is invalid, empty, or not a string
+ */
+export function normalizeUrl(url: string, includeSearchString?: boolean): string {
+  if (typeof url !== 'string') {
+    throw new Error('URL must be a string');
+  }
+
+  if (!url.trim()) {
+    throw new Error('URL cannot be empty');
+  }
+
+  try {
+    const urlObject = new URL(url);
+
+    return (
+      urlObject.origin +
+      (urlObject.pathname.endsWith('/') ? urlObject.pathname : urlObject.pathname + '/') +
+      (includeSearchString && urlObject.search ? urlObject.search : '')
+    );
+  } catch {
+    throw new Error(`Connection string ${url} is not a valid URL`);
+  }
+}
+
+/**
+ * Merges two URLs, combining their paths and query parameters.
+ * If loginUrlStr is an absolute URL, it takes precedence over baseUrlStr.
+ * If loginUrlStr is relative, it's merged with baseUrlStr.
+ *
+ * @param baseUrlStr - The base URL to merge with
+ * @param loginUrlStr - The login URL (can be absolute or relative)
+ * @returns The merged URL string
+ * @throws Error if baseUrlStr is not a valid URL
+ */
+export function mergeUrlsWithParams(baseUrlStr: string, loginUrlStr?: string): string {
+  if (!baseUrlStr) {
+    throw new Error('Base URL is required');
+  }
+
+  // Parse base URL first to validate it
+  let baseUrl: URL;
+  try {
+    baseUrl = new URL(baseUrlStr);
+  } catch {
+    throw new Error('Base URL is not valid');
+  }
+
+  // If no login URL provided or it's just a slash, return base URL
+  if (!loginUrlStr || loginUrlStr === '/') {
+    return baseUrl.toString();
+  }
+
+  try {
+    // Check if loginUrlStr is an absolute URL
+    const loginUrl = new URL(loginUrlStr);
+    return loginUrl.toString();
+  } catch {
+    // loginUrlStr is relative, proceed with merging
+  }
+
+  // Create a URL by joining base origin with login path
+  const resultUrl = new URL(baseUrl.toString());
+
+  // Split login URL into path and query parts
+  const [loginPath = '', loginQuery = ''] = loginUrlStr.split(/\?(.+)/);
+
+  // Handle the path merging
+  const basePath = baseUrl.pathname.replace(/\/$/, ''); // Remove trailing slash
+  const cleanLoginPath = loginPath
+    .replace(/^\/+/, '') // Remove leading slashes
+    .replace(/\/+$/, '') // Remove trailing slashes
+    .replace(/\/+/g, '/'); // Replace multiple slashes with single slash
+
+  resultUrl.pathname = cleanLoginPath ? `${basePath}/${cleanLoginPath}` : basePath;
+
+  // Parse and merge query parameters from both URLs
+  if (loginQuery) {
+    const loginParams = new URLSearchParams(loginQuery);
+    for (const [key, value] of loginParams.entries()) {
+      resultUrl.searchParams.set(key, value);
+    }
+  }
+
+  // Normalize the final URL by removing trailing slash
+  return normalizeUrl(resultUrl.toString(), true);
+}